Documentation

Overview

    Package kendra provides the API client, operations, and parameter types for AWSKendraFrontendService.

    Amazon Kendra is a service for indexing large document sets.

    Index

    Constants

    View Source
    const ServiceAPIVersion = "2019-02-03"
    View Source
    const ServiceID = "kendra"

    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 BatchDeleteDocumentInput

          type BatchDeleteDocumentInput struct {
          
          	// One or more identifiers for documents to delete from the index.
          	//
          	// This member is required.
          	DocumentIdList []string
          
          	// The identifier of the index that contains the documents to delete.
          	//
          	// This member is required.
          	IndexId *string
          
          	// Maps a particular data source sync job to a particular data source.
          	DataSourceSyncJobMetricTarget *types.DataSourceSyncJobMetricTarget
          }

          type BatchDeleteDocumentOutput

          type BatchDeleteDocumentOutput struct {
          
          	// A list of documents that could not be removed from the index. Each entry
          	// contains an error message that indicates why the document couldn't be removed
          	// from the index.
          	FailedDocuments []types.BatchDeleteDocumentResponseFailedDocument
          
          	// Metadata pertaining to the operation's result.
          	ResultMetadata middleware.Metadata
          }

          type BatchPutDocumentInput

          type BatchPutDocumentInput struct {
          
          	// One or more documents to add to the index. Documents have the following file
          	// size limits.
          	//
          	// * 5 MB total size for inline documents
          	//
          	// * 50 MB total size for
          	// files from an S3 bucket
          	//
          	// * 5 MB extracted text for any file
          	//
          	// For more
          	// information about file size and transaction per second quotas, see Quotas
          	// (https://docs.aws.amazon.com/kendra/latest/dg/quotas.html).
          	//
          	// This member is required.
          	Documents []types.Document
          
          	// The identifier of the index to add the documents to. You need to create the
          	// index first using the CreateIndex operation.
          	//
          	// This member is required.
          	IndexId *string
          
          	// The Amazon Resource Name (ARN) of a role that is allowed to run the
          	// BatchPutDocument operation. For more information, see IAM Roles for Amazon
          	// Kendra (https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html).
          	RoleArn *string
          }

          type BatchPutDocumentOutput

          type BatchPutDocumentOutput struct {
          
          	// A list of documents that were not added to the index because the document failed
          	// a validation check. Each document contains an error message that indicates why
          	// the document couldn't be added to the index. If there was an error adding a
          	// document to an index the error is reported in your AWS CloudWatch log. For more
          	// information, see Monitoring Amazon Kendra with Amazon CloudWatch Logs
          	// (https://docs.aws.amazon.com/kendra/latest/dg/cloudwatch-logs.html)
          	FailedDocuments []types.BatchPutDocumentResponseFailedDocument
          
          	// 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 AWSKendraFrontendService.

            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) BatchDeleteDocument

                func (c *Client) BatchDeleteDocument(ctx context.Context, params *BatchDeleteDocumentInput, optFns ...func(*Options)) (*BatchDeleteDocumentOutput, error)

                  Removes one or more documents from an index. The documents must have been added with the BatchPutDocument operation. The documents are deleted asynchronously. You can see the progress of the deletion by using AWS CloudWatch. Any error messages releated to the processing of the batch are sent to you CloudWatch log.

                  func (*Client) BatchPutDocument

                  func (c *Client) BatchPutDocument(ctx context.Context, params *BatchPutDocumentInput, optFns ...func(*Options)) (*BatchPutDocumentOutput, error)

                    Adds one or more documents to an index. The BatchPutDocument operation enables you to ingest inline documents or a set of documents stored in an Amazon S3 bucket. Use this operation to ingest your text and unstructured text into an index, add custom attributes to the documents, and to attach an access control list to the documents added to the index. The documents are indexed asynchronously. You can see the progress of the batch using AWS CloudWatch. Any error messages related to processing the batch are sent to your AWS CloudWatch log.

                    func (*Client) CreateDataSource

                    func (c *Client) CreateDataSource(ctx context.Context, params *CreateDataSourceInput, optFns ...func(*Options)) (*CreateDataSourceOutput, error)

                      Creates a data source that you use to with an Amazon Kendra index. You specify a name, data source connector type and description for your data source. You also specify configuration information such as document metadata (author, source URI, and so on) and user context information. CreateDataSource is a synchronous operation. The operation returns 200 if the data source was successfully created. Otherwise, an exception is raised.

                      func (*Client) CreateFaq

                      func (c *Client) CreateFaq(ctx context.Context, params *CreateFaqInput, optFns ...func(*Options)) (*CreateFaqOutput, error)

                        Creates an new set of frequently asked question (FAQ) questions and answers.

                        func (*Client) CreateIndex

                        func (c *Client) CreateIndex(ctx context.Context, params *CreateIndexInput, optFns ...func(*Options)) (*CreateIndexOutput, error)

                          Creates a new Amazon Kendra index. Index creation is an asynchronous operation. To determine if index creation has completed, check the Status field returned from a call to . The Status field is set to ACTIVE when the index is ready to use. Once the index is active you can index your documents using the operation or using one of the supported data sources.

                          func (*Client) CreateThesaurus

                          func (c *Client) CreateThesaurus(ctx context.Context, params *CreateThesaurusInput, optFns ...func(*Options)) (*CreateThesaurusOutput, error)

                            Creates a thesaurus for an index. The thesaurus contains a list of synonyms in Solr format.

                            func (*Client) DeleteDataSource

                            func (c *Client) DeleteDataSource(ctx context.Context, params *DeleteDataSourceInput, optFns ...func(*Options)) (*DeleteDataSourceOutput, error)

                              Deletes an Amazon Kendra data source. An exception is not thrown if the data source is already being deleted. While the data source is being deleted, the Status field returned by a call to the operation is set to DELETING. For more information, see Deleting Data Sources (https://docs.aws.amazon.com/kendra/latest/dg/delete-data-source.html).

                              func (*Client) DeleteFaq

                              func (c *Client) DeleteFaq(ctx context.Context, params *DeleteFaqInput, optFns ...func(*Options)) (*DeleteFaqOutput, error)

                                Removes an FAQ from an index.

                                func (*Client) DeleteIndex

                                func (c *Client) DeleteIndex(ctx context.Context, params *DeleteIndexInput, optFns ...func(*Options)) (*DeleteIndexOutput, error)

                                  Deletes an existing Amazon Kendra index. An exception is not thrown if the index is already being deleted. While the index is being deleted, the Status field returned by a call to the DescribeIndex operation is set to DELETING.

                                  func (*Client) DeleteThesaurus

                                  func (c *Client) DeleteThesaurus(ctx context.Context, params *DeleteThesaurusInput, optFns ...func(*Options)) (*DeleteThesaurusOutput, error)

                                    Deletes an existing Amazon Kendra thesaurus.

                                    func (*Client) DescribeDataSource

                                    func (c *Client) DescribeDataSource(ctx context.Context, params *DescribeDataSourceInput, optFns ...func(*Options)) (*DescribeDataSourceOutput, error)

                                      Gets information about a Amazon Kendra data source.

                                      func (*Client) DescribeFaq

                                      func (c *Client) DescribeFaq(ctx context.Context, params *DescribeFaqInput, optFns ...func(*Options)) (*DescribeFaqOutput, error)

                                        Gets information about an FAQ list.

                                        func (*Client) DescribeIndex

                                        func (c *Client) DescribeIndex(ctx context.Context, params *DescribeIndexInput, optFns ...func(*Options)) (*DescribeIndexOutput, error)

                                          Describes an existing Amazon Kendra index

                                          func (*Client) DescribeThesaurus

                                          func (c *Client) DescribeThesaurus(ctx context.Context, params *DescribeThesaurusInput, optFns ...func(*Options)) (*DescribeThesaurusOutput, error)

                                            Describes an existing Amazon Kendra thesaurus.

                                            func (*Client) ListDataSourceSyncJobs

                                            func (c *Client) ListDataSourceSyncJobs(ctx context.Context, params *ListDataSourceSyncJobsInput, optFns ...func(*Options)) (*ListDataSourceSyncJobsOutput, error)

                                              Gets statistics about synchronizing Amazon Kendra with a data source.

                                              func (*Client) ListDataSources

                                              func (c *Client) ListDataSources(ctx context.Context, params *ListDataSourcesInput, optFns ...func(*Options)) (*ListDataSourcesOutput, error)

                                                Lists the data sources that you have created.

                                                func (*Client) ListFaqs

                                                func (c *Client) ListFaqs(ctx context.Context, params *ListFaqsInput, optFns ...func(*Options)) (*ListFaqsOutput, error)

                                                  Gets a list of FAQ lists associated with an index.

                                                  func (*Client) ListIndices

                                                  func (c *Client) ListIndices(ctx context.Context, params *ListIndicesInput, optFns ...func(*Options)) (*ListIndicesOutput, error)

                                                    Lists the Amazon Kendra indexes that you have created.

                                                    func (*Client) ListTagsForResource

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

                                                      Gets a list of tags associated with a specified resource. Indexes, FAQs, and data sources can have tags associated with them.

                                                      func (*Client) ListThesauri

                                                      func (c *Client) ListThesauri(ctx context.Context, params *ListThesauriInput, optFns ...func(*Options)) (*ListThesauriOutput, error)

                                                        Lists the Amazon Kendra thesauri associated with an index.

                                                        func (*Client) Query

                                                        func (c *Client) Query(ctx context.Context, params *QueryInput, optFns ...func(*Options)) (*QueryOutput, error)

                                                          Searches an active index. Use this API to search your documents using query. The Query operation enables to do faceted search and to filter results based on document attributes. It also enables you to provide user context that Amazon Kendra uses to enforce document access control in the search results. Amazon Kendra searches your index for text content and question and answer (FAQ) content. By default the response contains three types of results.

                                                          * Relevant passages

                                                          * Matching FAQs

                                                          * Relevant documents

                                                          You can specify that the query return only one type of result using the QueryResultTypeConfig parameter. Each query returns the 100 most relevant results.

                                                          func (*Client) StartDataSourceSyncJob

                                                          func (c *Client) StartDataSourceSyncJob(ctx context.Context, params *StartDataSourceSyncJobInput, optFns ...func(*Options)) (*StartDataSourceSyncJobOutput, error)

                                                            Starts a synchronization job for a data source. If a synchronization job is already in progress, Amazon Kendra returns a ResourceInUseException exception.

                                                            func (*Client) StopDataSourceSyncJob

                                                            func (c *Client) StopDataSourceSyncJob(ctx context.Context, params *StopDataSourceSyncJobInput, optFns ...func(*Options)) (*StopDataSourceSyncJobOutput, error)

                                                              Stops a running synchronization job. You can't stop a scheduled synchronization job.

                                                              func (*Client) SubmitFeedback

                                                              func (c *Client) SubmitFeedback(ctx context.Context, params *SubmitFeedbackInput, optFns ...func(*Options)) (*SubmitFeedbackOutput, error)

                                                                Enables you to provide feedback to Amazon Kendra to improve the performance of the service.

                                                                func (*Client) TagResource

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

                                                                  Adds the specified tag to the specified index, FAQ, or data source resource. If the tag already exists, the existing value is replaced with the new value.

                                                                  func (*Client) UntagResource

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

                                                                    Removes a tag from an index, FAQ, or a data source.

                                                                    func (*Client) UpdateDataSource

                                                                    func (c *Client) UpdateDataSource(ctx context.Context, params *UpdateDataSourceInput, optFns ...func(*Options)) (*UpdateDataSourceOutput, error)

                                                                      Updates an existing Amazon Kendra data source.

                                                                      func (*Client) UpdateIndex

                                                                      func (c *Client) UpdateIndex(ctx context.Context, params *UpdateIndexInput, optFns ...func(*Options)) (*UpdateIndexOutput, error)

                                                                        Updates an existing Amazon Kendra index.

                                                                        func (*Client) UpdateThesaurus

                                                                        func (c *Client) UpdateThesaurus(ctx context.Context, params *UpdateThesaurusInput, optFns ...func(*Options)) (*UpdateThesaurusOutput, error)

                                                                          Updates a thesaurus file associated with an index.

                                                                          type CreateDataSourceInput

                                                                          type CreateDataSourceInput struct {
                                                                          
                                                                          	// The identifier of the index that should be associated with this data source.
                                                                          	//
                                                                          	// This member is required.
                                                                          	IndexId *string
                                                                          
                                                                          	// A unique name for the data source. A data source name can't be changed without
                                                                          	// deleting and recreating the data source.
                                                                          	//
                                                                          	// This member is required.
                                                                          	Name *string
                                                                          
                                                                          	// The type of repository that contains the data source.
                                                                          	//
                                                                          	// This member is required.
                                                                          	Type types.DataSourceType
                                                                          
                                                                          	// A token that you provide to identify the request to create a data source.
                                                                          	// Multiple calls to the CreateDataSource operation with the same client token will
                                                                          	// create only one data source.
                                                                          	ClientToken *string
                                                                          
                                                                          	// The connector configuration information that is required to access the
                                                                          	// repository. You can't specify the Configuration parameter when the Type
                                                                          	// parameter is set to CUSTOM. If you do, you receive a ValidationException
                                                                          	// exception. The Configuration parameter is required for all other data sources.
                                                                          	Configuration *types.DataSourceConfiguration
                                                                          
                                                                          	// A description for the data source.
                                                                          	Description *string
                                                                          
                                                                          	// The Amazon Resource Name (ARN) of a role with permission to access the data
                                                                          	// source. For more information, see IAM Roles for Amazon Kendra
                                                                          	// (https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html). You can't specify
                                                                          	// the RoleArn parameter when the Type parameter is set to CUSTOM. If you do, you
                                                                          	// receive a ValidationException exception. The RoleArn parameter is required for
                                                                          	// all other data sources.
                                                                          	RoleArn *string
                                                                          
                                                                          	// Sets the frequency that Amazon Kendra will check the documents in your
                                                                          	// repository and update the index. If you don't set a schedule Amazon Kendra will
                                                                          	// not periodically update the index. You can call the StartDataSourceSyncJob
                                                                          	// operation to update the index. You can't specify the Schedule parameter when the
                                                                          	// Type parameter is set to CUSTOM. If you do, you receive a ValidationException
                                                                          	// exception.
                                                                          	Schedule *string
                                                                          
                                                                          	// A list of key-value pairs that identify the data source. You can use the tags to
                                                                          	// identify and organize your resources and to control access to resources.
                                                                          	Tags []types.Tag
                                                                          }

                                                                          type CreateDataSourceOutput

                                                                          type CreateDataSourceOutput struct {
                                                                          
                                                                          	// A unique identifier for the data source.
                                                                          	//
                                                                          	// This member is required.
                                                                          	Id *string
                                                                          
                                                                          	// Metadata pertaining to the operation's result.
                                                                          	ResultMetadata middleware.Metadata
                                                                          }

                                                                          type CreateFaqInput

                                                                          type CreateFaqInput struct {
                                                                          
                                                                          	// The identifier of the index that contains the FAQ.
                                                                          	//
                                                                          	// This member is required.
                                                                          	IndexId *string
                                                                          
                                                                          	// The name that should be associated with the FAQ.
                                                                          	//
                                                                          	// This member is required.
                                                                          	Name *string
                                                                          
                                                                          	// The Amazon Resource Name (ARN) of a role with permission to access the S3 bucket
                                                                          	// that contains the FAQs. For more information, see IAM Roles for Amazon Kendra
                                                                          	// (https://docs.aws.amazon.com/kendra/latest/dg/iam-roles.html).
                                                                          	//
                                                                          	// This member is required.
                                                                          	RoleArn *string
                                                                          
                                                                          	// The S3 location of the FAQ input data.
                                                                          	//
                                                                          	// This member is required.
                                                                          	S3Path *types.S3Path
                                                                          
                                                                          	// A token that you provide to identify the request to create a FAQ. Multiple calls
                                                                          	// to the CreateFaqRequest operation with the same client token will create only
                                                                          	// one FAQ.
                                                                          	ClientToken *string
                                                                          
                                                                          	// A description of the FAQ.
                                                                          	Description *string
                                                                          
                                                                          	// The format of the input file. You can choose between a basic CSV format, a CSV
                                                                          	// format that includes customs attributes in a header, and a JSON format that
                                                                          	// includes custom attributes. The format must match the format of the file stored
                                                                          	// in the S3 bucket identified in the S3Path parameter. For more information, see
                                                                          	// Adding questions and answers
                                                                          	// (https://docs.aws.amazon.com/kendra/latest/dg/in-creating-faq.html).
                                                                          	FileFormat types.FaqFileFormat
                                                                          
                                                                          	// A list of key-value pairs that identify the FAQ. You can use the tags to
                                                                          	// identify and organize your resources and to control access to resources.
                                                                          	Tags []types.Tag
                                                                          }

                                                                          type CreateFaqOutput

                                                                          type CreateFaqOutput struct {
                                                                          
                                                                          	// The unique identifier of the FAQ.
                                                                          	Id *string
                                                                          
                                                                          	// Metadata pertaining to the operation's result.
                                                                          	ResultMetadata middleware.Metadata
                                                                          }

                                                                          type CreateIndexInput

                                                                          type CreateIndexInput struct {
                                                                          
                                                                          	// The name for the new index.
                                                                          	//
                                                                          	// This member is required.
                                                                          	Name *string
                                                                          
                                                                          	// An AWS Identity and Access Management (IAM) role that gives Amazon Kendra
                                                                          	// permissions to access your Amazon CloudWatch logs and metrics. This is also the
                                                                          	// role used when you use the BatchPutDocument operation to index documents from an
                                                                          	// Amazon S3 bucket.
                                                                          	//
                                                                          	// This member is required.
                                                                          	RoleArn *string
                                                                          
                                                                          	// A token that you provide to identify the request to create an index. Multiple
                                                                          	// calls to the CreateIndex operation with the same client token will create only
                                                                          	// one index.
                                                                          	ClientToken *string
                                                                          
                                                                          	// A description for the index.
                                                                          	Description *string
                                                                          
                                                                          	// The Amazon Kendra edition to use for the index. Choose DEVELOPER_EDITION for
                                                                          	// indexes intended for development, testing, or proof of concept. Use
                                                                          	// ENTERPRISE_EDITION for your production databases. Once you set the edition for
                                                                          	// an index, it can't be changed. The Edition parameter is optional. If you don't
                                                                          	// supply a value, the default is ENTERPRISE_EDITION.
                                                                          	Edition types.IndexEdition
                                                                          
                                                                          	// The identifier of the AWS KMS customer managed key (CMK) to use to encrypt data
                                                                          	// indexed by Amazon Kendra. Amazon Kendra doesn't support asymmetric CMKs.
                                                                          	ServerSideEncryptionConfiguration *types.ServerSideEncryptionConfiguration
                                                                          
                                                                          	// A list of key-value pairs that identify the index. You can use the tags to
                                                                          	// identify and organize your resources and to control access to resources.
                                                                          	Tags []types.Tag
                                                                          
                                                                          	// The user context policy. ATTRIBUTE_FILTER All indexed content is searchable and
                                                                          	// displayable for all users. If there is an access control list, it is ignored.
                                                                          	// You can filter on user and group attributes. USER_TOKEN Enables SSO and
                                                                          	// token-based user access control. All documents with no access control and all
                                                                          	// documents accessible to the user will be searchable and displayable.
                                                                          	UserContextPolicy types.UserContextPolicy
                                                                          
                                                                          	// The user token configuration.
                                                                          	UserTokenConfigurations []types.UserTokenConfiguration
                                                                          }

                                                                          type CreateIndexOutput

                                                                          type CreateIndexOutput struct {
                                                                          
                                                                          	// The unique identifier of the index. Use this identifier when you query an index,
                                                                          	// set up a data source, or index a document.
                                                                          	Id *string
                                                                          
                                                                          	// Metadata pertaining to the operation's result.
                                                                          	ResultMetadata middleware.Metadata
                                                                          }

                                                                          type CreateThesaurusInput

                                                                          type CreateThesaurusInput struct {
                                                                          
                                                                          	// The unique identifier of the index for the new thesaurus.
                                                                          	//
                                                                          	// This member is required.
                                                                          	IndexId *string
                                                                          
                                                                          	// The name for the new thesaurus.
                                                                          	//
                                                                          	// This member is required.
                                                                          	Name *string
                                                                          
                                                                          	// An AWS Identity and Access Management (IAM) role that gives Amazon Kendra
                                                                          	// permissions to access thesaurus file specified in SourceS3Path.
                                                                          	//
                                                                          	// This member is required.
                                                                          	RoleArn *string
                                                                          
                                                                          	// The thesaurus file Amazon S3 source path.
                                                                          	//
                                                                          	// This member is required.
                                                                          	SourceS3Path *types.S3Path
                                                                          
                                                                          	// A token that you provide to identify the request to create a thesaurus. Multiple
                                                                          	// calls to the CreateThesaurus operation with the same client token will create
                                                                          	// only one index.
                                                                          	ClientToken *string
                                                                          
                                                                          	// The description for the new thesaurus.
                                                                          	Description *string
                                                                          
                                                                          	// A list of key-value pairs that identify the thesaurus. You can use the tags to
                                                                          	// identify and organize your resources and to control access to resources.
                                                                          	Tags []types.Tag
                                                                          }

                                                                          type CreateThesaurusOutput

                                                                          type CreateThesaurusOutput struct {
                                                                          
                                                                          	// The unique identifier of the thesaurus.
                                                                          	Id *string
                                                                          
                                                                          	// Metadata pertaining to the operation's result.
                                                                          	ResultMetadata middleware.Metadata
                                                                          }

                                                                          type DeleteDataSourceInput

                                                                          type DeleteDataSourceInput struct {
                                                                          
                                                                          	// The unique identifier of the data source to delete.
                                                                          	//
                                                                          	// This member is required.
                                                                          	Id *string
                                                                          
                                                                          	// The unique identifier of the index associated with the data source.
                                                                          	//
                                                                          	// This member is required.
                                                                          	IndexId *string
                                                                          }

                                                                          type DeleteDataSourceOutput

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

                                                                          type DeleteFaqInput

                                                                          type DeleteFaqInput struct {
                                                                          
                                                                          	// The identifier of the FAQ to remove.
                                                                          	//
                                                                          	// This member is required.
                                                                          	Id *string
                                                                          
                                                                          	// The index to remove the FAQ from.
                                                                          	//
                                                                          	// This member is required.
                                                                          	IndexId *string
                                                                          }

                                                                          type DeleteFaqOutput

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

                                                                          type DeleteIndexInput

                                                                          type DeleteIndexInput struct {
                                                                          
                                                                          	// The identifier of the index to delete.
                                                                          	//
                                                                          	// This member is required.
                                                                          	Id *string
                                                                          }

                                                                          type DeleteIndexOutput

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

                                                                          type DeleteThesaurusInput

                                                                          type DeleteThesaurusInput struct {
                                                                          
                                                                          	// The identifier of the thesaurus to delete.
                                                                          	//
                                                                          	// This member is required.
                                                                          	Id *string
                                                                          
                                                                          	// The identifier of the index associated with the thesaurus to delete.
                                                                          	//
                                                                          	// This member is required.
                                                                          	IndexId *string
                                                                          }

                                                                          type DeleteThesaurusOutput

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

                                                                          type DescribeDataSourceInput

                                                                          type DescribeDataSourceInput struct {
                                                                          
                                                                          	// The unique identifier of the data source to describe.
                                                                          	//
                                                                          	// This member is required.
                                                                          	Id *string
                                                                          
                                                                          	// The identifier of the index that contains the data source.
                                                                          	//
                                                                          	// This member is required.
                                                                          	IndexId *string
                                                                          }

                                                                          type DescribeDataSourceOutput

                                                                          type DescribeDataSourceOutput struct {
                                                                          
                                                                          	// Information that describes where the data source is located and how the data
                                                                          	// source is configured. The specific information in the description depends on the
                                                                          	// data source provider.
                                                                          	Configuration *types.DataSourceConfiguration
                                                                          
                                                                          	// The Unix timestamp of when the data source was created.
                                                                          	CreatedAt *time.Time
                                                                          
                                                                          	// The description of the data source.
                                                                          	Description *string
                                                                          
                                                                          	// When the Status field value is FAILED, the ErrorMessage field contains a
                                                                          	// description of the error that caused the data source to fail.
                                                                          	ErrorMessage *string
                                                                          
                                                                          	// The identifier of the data source.
                                                                          	Id *string
                                                                          
                                                                          	// The identifier of the index that contains the data source.
                                                                          	IndexId *string
                                                                          
                                                                          	// The name that you gave the data source when it was created.
                                                                          	Name *string
                                                                          
                                                                          	// The Amazon Resource Name (ARN) of the role that enables the data source to
                                                                          	// access its resources.
                                                                          	RoleArn *string
                                                                          
                                                                          	// The schedule that Amazon Kendra will update the data source.
                                                                          	Schedule *string
                                                                          
                                                                          	// The current status of the data source. When the status is ACTIVE the data source
                                                                          	// is ready to use. When the status is FAILED, the ErrorMessage field contains the
                                                                          	// reason that the data source failed.
                                                                          	Status types.DataSourceStatus
                                                                          
                                                                          	// The type of the data source.
                                                                          	Type types.DataSourceType
                                                                          
                                                                          	// The Unix timestamp of when the data source was last updated.
                                                                          	UpdatedAt *time.Time
                                                                          
                                                                          	// Metadata pertaining to the operation's result.
                                                                          	ResultMetadata middleware.Metadata
                                                                          }

                                                                          type DescribeFaqInput

                                                                          type DescribeFaqInput struct {
                                                                          
                                                                          	// The unique identifier of the FAQ.
                                                                          	//
                                                                          	// This member is required.
                                                                          	Id *string
                                                                          
                                                                          	// The identifier of the index that contains the FAQ.
                                                                          	//
                                                                          	// This member is required.
                                                                          	IndexId *string
                                                                          }

                                                                          type DescribeFaqOutput

                                                                          type DescribeFaqOutput struct {
                                                                          
                                                                          	// The date and time that the FAQ was created.
                                                                          	CreatedAt *time.Time
                                                                          
                                                                          	// The description of the FAQ that you provided when it was created.
                                                                          	Description *string
                                                                          
                                                                          	// If the Status field is FAILED, the ErrorMessage field contains the reason why
                                                                          	// the FAQ failed.
                                                                          	ErrorMessage *string
                                                                          
                                                                          	// The file format used by the input files for the FAQ.
                                                                          	FileFormat types.FaqFileFormat
                                                                          
                                                                          	// The identifier of the FAQ.
                                                                          	Id *string
                                                                          
                                                                          	// The identifier of the index that contains the FAQ.
                                                                          	IndexId *string
                                                                          
                                                                          	// The name that you gave the FAQ when it was created.
                                                                          	Name *string
                                                                          
                                                                          	// The Amazon Resource Name (ARN) of the role that provides access to the S3 bucket
                                                                          	// containing the input files for the FAQ.
                                                                          	RoleArn *string
                                                                          
                                                                          	// Information required to find a specific file in an Amazon S3 bucket.
                                                                          	S3Path *types.S3Path
                                                                          
                                                                          	// The status of the FAQ. It is ready to use when the status is ACTIVE.
                                                                          	Status types.FaqStatus
                                                                          
                                                                          	// The date and time that the FAQ was last updated.
                                                                          	UpdatedAt *time.Time
                                                                          
                                                                          	// Metadata pertaining to the operation's result.
                                                                          	ResultMetadata middleware.Metadata
                                                                          }

                                                                          type DescribeIndexInput

                                                                          type DescribeIndexInput struct {
                                                                          
                                                                          	// The name of the index to describe.
                                                                          	//
                                                                          	// This member is required.
                                                                          	Id *string
                                                                          }

                                                                          type DescribeIndexOutput

                                                                          type DescribeIndexOutput struct {
                                                                          
                                                                          	// For enterprise edtion indexes, you can choose to use additional capacity to meet
                                                                          	// the needs of your application. This contains the capacity units used for the
                                                                          	// index. A 0 for the query capacity or the storage capacity indicates that the
                                                                          	// index is using the default capacity for the index.
                                                                          	CapacityUnits *types.CapacityUnitsConfiguration
                                                                          
                                                                          	// The Unix datetime that the index was created.
                                                                          	CreatedAt *time.Time
                                                                          
                                                                          	// The description of the index.
                                                                          	Description *string
                                                                          
                                                                          	// Configuration settings for any metadata applied to the documents in the index.
                                                                          	DocumentMetadataConfigurations []types.DocumentMetadataConfiguration
                                                                          
                                                                          	// The Amazon Kendra edition used for the index. You decide the edition when you
                                                                          	// create the index.
                                                                          	Edition types.IndexEdition
                                                                          
                                                                          	// When th eStatus field value is FAILED, the ErrorMessage field contains a message
                                                                          	// that explains why.
                                                                          	ErrorMessage *string
                                                                          
                                                                          	// The name of the index.
                                                                          	Id *string
                                                                          
                                                                          	// Provides information about the number of FAQ questions and answers and the
                                                                          	// number of text documents indexed.
                                                                          	IndexStatistics *types.IndexStatistics
                                                                          
                                                                          	// The name of the index.
                                                                          	Name *string
                                                                          
                                                                          	// The Amazon Resource Name (ARN) of the IAM role that gives Amazon Kendra
                                                                          	// permission to write to your Amazon Cloudwatch logs.
                                                                          	RoleArn *string
                                                                          
                                                                          	// The identifier of the AWS KMS customer master key (CMK) used to encrypt your
                                                                          	// data. Amazon Kendra doesn't support asymmetric CMKs.
                                                                          	ServerSideEncryptionConfiguration *types.ServerSideEncryptionConfiguration
                                                                          
                                                                          	// The current status of the index. When the value is ACTIVE, the index is ready
                                                                          	// for use. If the Status field value is FAILED, the ErrorMessage field contains a
                                                                          	// message that explains why.
                                                                          	Status types.IndexStatus
                                                                          
                                                                          	// The Unix datetime that the index was last updated.
                                                                          	UpdatedAt *time.Time
                                                                          
                                                                          	// The user context policy for the Amazon Kendra index.
                                                                          	UserContextPolicy types.UserContextPolicy
                                                                          
                                                                          	// The user token configuration for the Amazon Kendra index.
                                                                          	UserTokenConfigurations []types.UserTokenConfiguration
                                                                          
                                                                          	// Metadata pertaining to the operation's result.
                                                                          	ResultMetadata middleware.Metadata
                                                                          }

                                                                          type DescribeThesaurusInput

                                                                          type DescribeThesaurusInput struct {
                                                                          
                                                                          	// The identifier of the thesaurus to describe.
                                                                          	//
                                                                          	// This member is required.
                                                                          	Id *string
                                                                          
                                                                          	// The identifier of the index associated with the thesaurus to describe.
                                                                          	//
                                                                          	// This member is required.
                                                                          	IndexId *string
                                                                          }

                                                                          type DescribeThesaurusOutput

                                                                          type DescribeThesaurusOutput struct {
                                                                          
                                                                          	// The Unix datetime that the thesaurus was created.
                                                                          	CreatedAt *time.Time
                                                                          
                                                                          	// The thesaurus description.
                                                                          	Description *string
                                                                          
                                                                          	// When the Status field value is FAILED, the ErrorMessage field provides more
                                                                          	// information.
                                                                          	ErrorMessage *string
                                                                          
                                                                          	// The size of the thesaurus file in bytes.
                                                                          	FileSizeBytes *int64
                                                                          
                                                                          	// The identifier of the thesaurus.
                                                                          	Id *string
                                                                          
                                                                          	// The identifier of the index associated with the thesaurus to describe.
                                                                          	IndexId *string
                                                                          
                                                                          	// The thesaurus name.
                                                                          	Name *string
                                                                          
                                                                          	// An AWS Identity and Access Management (IAM) role that gives Amazon Kendra
                                                                          	// permissions to access thesaurus file specified in SourceS3Path.
                                                                          	RoleArn *string
                                                                          
                                                                          	// Information required to find a specific file in an Amazon S3 bucket.
                                                                          	SourceS3Path *types.S3Path
                                                                          
                                                                          	// The current status of the thesaurus. When the value is ACTIVE, queries are able
                                                                          	// to use the thesaurus. If the Status field value is FAILED, the ErrorMessage
                                                                          	// field provides more information. If the status is ACTIVE_BUT_UPDATE_FAILED, it
                                                                          	// means that Amazon Kendra could not ingest the new thesaurus file. The old
                                                                          	// thesaurus file is still active.
                                                                          	Status types.ThesaurusStatus
                                                                          
                                                                          	// The number of synonym rules in the thesaurus file.
                                                                          	SynonymRuleCount *int64
                                                                          
                                                                          	// The number of unique terms in the thesaurus file. For example, the synonyms
                                                                          	// a,b,c and a=>d, the term count would be 4.
                                                                          	TermCount *int64
                                                                          
                                                                          	// The Unix datetime that the thesaurus was last updated.
                                                                          	UpdatedAt *time.Time
                                                                          
                                                                          	// 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 ListDataSourceSyncJobsAPIClient

                                                                                    type ListDataSourceSyncJobsAPIClient interface {
                                                                                    	ListDataSourceSyncJobs(context.Context, *ListDataSourceSyncJobsInput, ...func(*Options)) (*ListDataSourceSyncJobsOutput, error)
                                                                                    }

                                                                                      ListDataSourceSyncJobsAPIClient is a client that implements the ListDataSourceSyncJobs operation.

                                                                                      type ListDataSourceSyncJobsInput

                                                                                      type ListDataSourceSyncJobsInput struct {
                                                                                      
                                                                                      	// The identifier of the data source.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	Id *string
                                                                                      
                                                                                      	// The identifier of the index that contains the data source.
                                                                                      	//
                                                                                      	// This member is required.
                                                                                      	IndexId *string
                                                                                      
                                                                                      	// The maximum number of synchronization jobs to return in the response. If there
                                                                                      	// are fewer results in the list, this response contains only the actual results.
                                                                                      	MaxResults *int32
                                                                                      
                                                                                      	// If the result of the previous request to GetDataSourceSyncJobHistory was
                                                                                      	// truncated, include the NextToken to fetch the next set of jobs.
                                                                                      	NextToken *string
                                                                                      
                                                                                      	// When specified, the synchronization jobs returned in the list are limited to
                                                                                      	// jobs between the specified dates.
                                                                                      	StartTimeFilter *types.TimeRange
                                                                                      
                                                                                      	// When specified, only returns synchronization jobs with the Status field equal to
                                                                                      	// the specified status.
                                                                                      	StatusFilter types.DataSourceSyncJobStatus
                                                                                      }

                                                                                      type ListDataSourceSyncJobsOutput

                                                                                      type ListDataSourceSyncJobsOutput struct {
                                                                                      
                                                                                      	// A history of synchronization jobs for the data source.
                                                                                      	History []types.DataSourceSyncJob
                                                                                      
                                                                                      	// The GetDataSourceSyncJobHistory operation returns a page of vocabularies at a
                                                                                      	// time. The maximum size of the page is set by the MaxResults parameter. If there
                                                                                      	// are more jobs in the list than the page size, Amazon Kendra returns the NextPage
                                                                                      	// token. Include the token in the next request to the GetDataSourceSyncJobHistory
                                                                                      	// operation to return in the next page of jobs.
                                                                                      	NextToken *string
                                                                                      
                                                                                      	// Metadata pertaining to the operation's result.
                                                                                      	ResultMetadata middleware.Metadata
                                                                                      }

                                                                                      type ListDataSourceSyncJobsPaginator

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

                                                                                        ListDataSourceSyncJobsPaginator is a paginator for ListDataSourceSyncJobs

                                                                                        func NewListDataSourceSyncJobsPaginator

                                                                                          NewListDataSourceSyncJobsPaginator returns a new ListDataSourceSyncJobsPaginator

                                                                                          func (*ListDataSourceSyncJobsPaginator) HasMorePages

                                                                                          func (p *ListDataSourceSyncJobsPaginator) HasMorePages() bool

                                                                                            HasMorePages returns a boolean indicating whether more pages are available

                                                                                            func (*ListDataSourceSyncJobsPaginator) NextPage

                                                                                              NextPage retrieves the next ListDataSourceSyncJobs page.

                                                                                              type ListDataSourceSyncJobsPaginatorOptions

                                                                                              type ListDataSourceSyncJobsPaginatorOptions struct {
                                                                                              	// The maximum number of synchronization jobs to return in the response. If there
                                                                                              	// are fewer results in the list, this response contains only the actual results.
                                                                                              	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
                                                                                              }

                                                                                                ListDataSourceSyncJobsPaginatorOptions is the paginator options for ListDataSourceSyncJobs

                                                                                                type ListDataSourcesAPIClient

                                                                                                type ListDataSourcesAPIClient interface {
                                                                                                	ListDataSources(context.Context, *ListDataSourcesInput, ...func(*Options)) (*ListDataSourcesOutput, error)
                                                                                                }

                                                                                                  ListDataSourcesAPIClient is a client that implements the ListDataSources operation.

                                                                                                  type ListDataSourcesInput

                                                                                                  type ListDataSourcesInput struct {
                                                                                                  
                                                                                                  	// The identifier of the index that contains the data source.
                                                                                                  	//
                                                                                                  	// This member is required.
                                                                                                  	IndexId *string
                                                                                                  
                                                                                                  	// The maximum number of data sources to return.
                                                                                                  	MaxResults *int32
                                                                                                  
                                                                                                  	// If the previous response was incomplete (because there is more data to
                                                                                                  	// retrieve), Amazon Kendra returns a pagination token in the response. You can use
                                                                                                  	// this pagination token to retrieve the next set of data sources
                                                                                                  	// (DataSourceSummaryItems).
                                                                                                  	NextToken *string
                                                                                                  }

                                                                                                  type ListDataSourcesOutput

                                                                                                  type ListDataSourcesOutput struct {
                                                                                                  
                                                                                                  	// If the response is truncated, Amazon Kendra returns this token that you can use
                                                                                                  	// in the subsequent request to retrieve the next set of data sources.
                                                                                                  	NextToken *string
                                                                                                  
                                                                                                  	// An array of summary information for one or more data sources.
                                                                                                  	SummaryItems []types.DataSourceSummary
                                                                                                  
                                                                                                  	// Metadata pertaining to the operation's result.
                                                                                                  	ResultMetadata middleware.Metadata
                                                                                                  }

                                                                                                  type ListDataSourcesPaginator

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

                                                                                                    ListDataSourcesPaginator is a paginator for ListDataSources

                                                                                                    func NewListDataSourcesPaginator

                                                                                                    func NewListDataSourcesPaginator(client ListDataSourcesAPIClient, params *ListDataSourcesInput, optFns ...func(*ListDataSourcesPaginatorOptions)) *ListDataSourcesPaginator

                                                                                                      NewListDataSourcesPaginator returns a new ListDataSourcesPaginator

                                                                                                      func (*ListDataSourcesPaginator) HasMorePages

                                                                                                      func (p *ListDataSourcesPaginator) HasMorePages() bool

                                                                                                        HasMorePages returns a boolean indicating whether more pages are available

                                                                                                        func (*ListDataSourcesPaginator) NextPage

                                                                                                        func (p *ListDataSourcesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListDataSourcesOutput, error)

                                                                                                          NextPage retrieves the next ListDataSources page.

                                                                                                          type ListDataSourcesPaginatorOptions

                                                                                                          type ListDataSourcesPaginatorOptions struct {
                                                                                                          	// The maximum number of data sources to return.
                                                                                                          	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
                                                                                                          }

                                                                                                            ListDataSourcesPaginatorOptions is the paginator options for ListDataSources

                                                                                                            type ListFaqsInput

                                                                                                            type ListFaqsInput struct {
                                                                                                            
                                                                                                            	// The index that contains the FAQ lists.
                                                                                                            	//
                                                                                                            	// This member is required.
                                                                                                            	IndexId *string
                                                                                                            
                                                                                                            	// The maximum number of FAQs to return in the response. If there are fewer results
                                                                                                            	// in the list, this response contains only the actual results.
                                                                                                            	MaxResults *int32
                                                                                                            
                                                                                                            	// If the result of the previous request to ListFaqs was truncated, include the
                                                                                                            	// NextToken to fetch the next set of FAQs.
                                                                                                            	NextToken *string
                                                                                                            }

                                                                                                            type ListFaqsOutput

                                                                                                            type ListFaqsOutput struct {
                                                                                                            
                                                                                                            	// information about the FAQs associated with the specified index.
                                                                                                            	FaqSummaryItems []types.FaqSummary
                                                                                                            
                                                                                                            	// The ListFaqs operation returns a page of FAQs at a time. The maximum size of the
                                                                                                            	// page is set by the MaxResults parameter. If there are more jobs in the list than
                                                                                                            	// the page size, Amazon Kendra returns the NextPage token. Include the token in
                                                                                                            	// the next request to the ListFaqs operation to return the next page of FAQs.
                                                                                                            	NextToken *string
                                                                                                            
                                                                                                            	// Metadata pertaining to the operation's result.
                                                                                                            	ResultMetadata middleware.Metadata
                                                                                                            }

                                                                                                            type ListIndicesAPIClient

                                                                                                            type ListIndicesAPIClient interface {
                                                                                                            	ListIndices(context.Context, *ListIndicesInput, ...func(*Options)) (*ListIndicesOutput, error)
                                                                                                            }

                                                                                                              ListIndicesAPIClient is a client that implements the ListIndices operation.

                                                                                                              type ListIndicesInput

                                                                                                              type ListIndicesInput struct {
                                                                                                              
                                                                                                              	// The maximum number of data sources to return.
                                                                                                              	MaxResults *int32
                                                                                                              
                                                                                                              	// If the previous response was incomplete (because there is more data to
                                                                                                              	// retrieve), Amazon Kendra returns a pagination token in the response. You can use
                                                                                                              	// this pagination token to retrieve the next set of indexes
                                                                                                              	// (DataSourceSummaryItems).
                                                                                                              	NextToken *string
                                                                                                              }

                                                                                                              type ListIndicesOutput

                                                                                                              type ListIndicesOutput struct {
                                                                                                              
                                                                                                              	// An array of summary information for one or more indexes.
                                                                                                              	IndexConfigurationSummaryItems []types.IndexConfigurationSummary
                                                                                                              
                                                                                                              	// If the response is truncated, Amazon Kendra returns this token that you can use
                                                                                                              	// in the subsequent request to retrieve the next set of indexes.
                                                                                                              	NextToken *string
                                                                                                              
                                                                                                              	// Metadata pertaining to the operation's result.
                                                                                                              	ResultMetadata middleware.Metadata
                                                                                                              }

                                                                                                              type ListIndicesPaginator

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

                                                                                                                ListIndicesPaginator is a paginator for ListIndices

                                                                                                                func NewListIndicesPaginator

                                                                                                                func NewListIndicesPaginator(client ListIndicesAPIClient, params *ListIndicesInput, optFns ...func(*ListIndicesPaginatorOptions)) *ListIndicesPaginator

                                                                                                                  NewListIndicesPaginator returns a new ListIndicesPaginator

                                                                                                                  func (*ListIndicesPaginator) HasMorePages

                                                                                                                  func (p *ListIndicesPaginator) HasMorePages() bool

                                                                                                                    HasMorePages returns a boolean indicating whether more pages are available

                                                                                                                    func (*ListIndicesPaginator) NextPage

                                                                                                                    func (p *ListIndicesPaginator) NextPage(ctx context.Context, optFns ...func(*Options)) (*ListIndicesOutput, error)

                                                                                                                      NextPage retrieves the next ListIndices page.

                                                                                                                      type ListIndicesPaginatorOptions

                                                                                                                      type ListIndicesPaginatorOptions struct {
                                                                                                                      	// The maximum number of data sources to return.
                                                                                                                      	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
                                                                                                                      }

                                                                                                                        ListIndicesPaginatorOptions is the paginator options for ListIndices

                                                                                                                        type ListTagsForResourceInput

                                                                                                                        type ListTagsForResourceInput struct {
                                                                                                                        
                                                                                                                        	// The Amazon Resource Name (ARN) of the index, FAQ, or data source to get a list
                                                                                                                        	// of tags for.
                                                                                                                        	//
                                                                                                                        	// This member is required.
                                                                                                                        	ResourceARN *string
                                                                                                                        }

                                                                                                                        type ListTagsForResourceOutput

                                                                                                                        type ListTagsForResourceOutput struct {
                                                                                                                        
                                                                                                                        	// A list of tags associated with the index, FAQ, or data source.
                                                                                                                        	Tags []types.Tag
                                                                                                                        
                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                        }

                                                                                                                        type ListThesauriInput

                                                                                                                        type ListThesauriInput struct {
                                                                                                                        
                                                                                                                        	// The identifier of the index associated with the thesaurus to list.
                                                                                                                        	//
                                                                                                                        	// This member is required.
                                                                                                                        	IndexId *string
                                                                                                                        
                                                                                                                        	// The maximum number of thesauri to return.
                                                                                                                        	MaxResults *int32
                                                                                                                        
                                                                                                                        	// If the previous response was incomplete (because there is more data to
                                                                                                                        	// retrieve), Amazon Kendra returns a pagination token in the response. You can use
                                                                                                                        	// this pagination token to retrieve the next set of thesauri
                                                                                                                        	// (ThesaurusSummaryItems).
                                                                                                                        	NextToken *string
                                                                                                                        }

                                                                                                                        type ListThesauriOutput

                                                                                                                        type ListThesauriOutput struct {
                                                                                                                        
                                                                                                                        	// If the response is truncated, Amazon Kendra returns this token that you can use
                                                                                                                        	// in the subsequent request to retrieve the next set of thesauri.
                                                                                                                        	NextToken *string
                                                                                                                        
                                                                                                                        	// An array of summary information for one or more thesauruses.
                                                                                                                        	ThesaurusSummaryItems []types.ThesaurusSummary
                                                                                                                        
                                                                                                                        	// Metadata pertaining to the operation's result.
                                                                                                                        	ResultMetadata middleware.Metadata
                                                                                                                        }

                                                                                                                        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 QueryInput

                                                                                                                          type QueryInput struct {
                                                                                                                          
                                                                                                                          	// The unique identifier of the index to search. The identifier is returned in the
                                                                                                                          	// response from the operation.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	IndexId *string
                                                                                                                          
                                                                                                                          	// The text to search for.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	QueryText *string
                                                                                                                          
                                                                                                                          	// Enables filtered searches based on document attributes. You can only provide one
                                                                                                                          	// attribute filter; however, the AndAllFilters, NotFilter, and OrAllFilters
                                                                                                                          	// parameters contain a list of other filters. The AttributeFilter parameter
                                                                                                                          	// enables you to create a set of filtering rules that a document must satisfy to
                                                                                                                          	// be included in the query results.
                                                                                                                          	AttributeFilter *types.AttributeFilter
                                                                                                                          
                                                                                                                          	// An array of documents attributes. Amazon Kendra returns a count for each
                                                                                                                          	// attribute key specified. You can use this information to help narrow the search
                                                                                                                          	// for your user.
                                                                                                                          	Facets []types.Facet
                                                                                                                          
                                                                                                                          	// Query results are returned in pages the size of the PageSize parameter. By
                                                                                                                          	// default, Amazon Kendra returns the first page of results. Use this parameter to
                                                                                                                          	// get result pages after the first one.
                                                                                                                          	PageNumber *int32
                                                                                                                          
                                                                                                                          	// Sets the number of results that are returned in each page of results. The
                                                                                                                          	// default page size is 10. The maximum number of results returned is 100. If you
                                                                                                                          	// ask for more than 100 results, only 100 are returned.
                                                                                                                          	PageSize *int32
                                                                                                                          
                                                                                                                          	// Sets the type of query. Only results for the specified query type are returned.
                                                                                                                          	QueryResultTypeFilter types.QueryResultType
                                                                                                                          
                                                                                                                          	// An array of document attributes to include in the response. No other document
                                                                                                                          	// attributes are included in the response. By default all document attributes are
                                                                                                                          	// included in the response.
                                                                                                                          	RequestedDocumentAttributes []string
                                                                                                                          
                                                                                                                          	// Provides information that determines how the results of the query are sorted.
                                                                                                                          	// You can set the field that Amazon Kendra should sort the results on, and specify
                                                                                                                          	// whether the results should be sorted in ascending or descending order. In the
                                                                                                                          	// case of ties in sorting the results, the results are sorted by relevance. If you
                                                                                                                          	// don't provide sorting configuration, the results are sorted by the relevance
                                                                                                                          	// that Amazon Kendra determines for the result.
                                                                                                                          	SortingConfiguration *types.SortingConfiguration
                                                                                                                          
                                                                                                                          	// The user context token.
                                                                                                                          	UserContext *types.UserContext
                                                                                                                          
                                                                                                                          	// Provides an identifier for a specific user. The VisitorId should be a unique
                                                                                                                          	// identifier, such as a GUID. Don't use personally identifiable information, such
                                                                                                                          	// as the user's email address, as the VisitorId.
                                                                                                                          	VisitorId *string
                                                                                                                          }

                                                                                                                          type QueryOutput

                                                                                                                          type QueryOutput struct {
                                                                                                                          
                                                                                                                          	// Contains the facet results. A FacetResult contains the counts for each attribute
                                                                                                                          	// key that was specified in the Facets input parameter.
                                                                                                                          	FacetResults []types.FacetResult
                                                                                                                          
                                                                                                                          	// The unique identifier for the search. You use QueryId to identify the search
                                                                                                                          	// when using the feedback API.
                                                                                                                          	QueryId *string
                                                                                                                          
                                                                                                                          	// The results of the search.
                                                                                                                          	ResultItems []types.QueryResultItem
                                                                                                                          
                                                                                                                          	// The total number of items found by the search; however, you can only retrieve up
                                                                                                                          	// to 100 items. For example, if the search found 192 items, you can only retrieve
                                                                                                                          	// the first 100 of the items.
                                                                                                                          	TotalNumberOfResults *int32
                                                                                                                          
                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                          }

                                                                                                                          type ResolveEndpoint

                                                                                                                          type ResolveEndpoint struct {
                                                                                                                          	Resolver EndpointResolver
                                                                                                                          	Options  EndpointResolverOptions
                                                                                                                          }

                                                                                                                          func (*ResolveEndpoint) HandleSerialize

                                                                                                                          func (*ResolveEndpoint) ID

                                                                                                                          func (*ResolveEndpoint) ID() string

                                                                                                                          type StartDataSourceSyncJobInput

                                                                                                                          type StartDataSourceSyncJobInput struct {
                                                                                                                          
                                                                                                                          	// The identifier of the data source to synchronize.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	Id *string
                                                                                                                          
                                                                                                                          	// The identifier of the index that contains the data source.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	IndexId *string
                                                                                                                          }

                                                                                                                          type StartDataSourceSyncJobOutput

                                                                                                                          type StartDataSourceSyncJobOutput struct {
                                                                                                                          
                                                                                                                          	// Identifies a particular synchronization job.
                                                                                                                          	ExecutionId *string
                                                                                                                          
                                                                                                                          	// Metadata pertaining to the operation's result.
                                                                                                                          	ResultMetadata middleware.Metadata
                                                                                                                          }

                                                                                                                          type StopDataSourceSyncJobInput

                                                                                                                          type StopDataSourceSyncJobInput struct {
                                                                                                                          
                                                                                                                          	// The identifier of the data source for which to stop the synchronization jobs.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	Id *string
                                                                                                                          
                                                                                                                          	// The identifier of the index that contains the data source.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	IndexId *string
                                                                                                                          }

                                                                                                                          type StopDataSourceSyncJobOutput

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

                                                                                                                          type SubmitFeedbackInput

                                                                                                                          type SubmitFeedbackInput struct {
                                                                                                                          
                                                                                                                          	// The identifier of the index that was queried.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	IndexId *string
                                                                                                                          
                                                                                                                          	// The identifier of the specific query for which you are submitting feedback. The
                                                                                                                          	// query ID is returned in the response to the operation.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	QueryId *string
                                                                                                                          
                                                                                                                          	// Tells Amazon Kendra that a particular search result link was chosen by the user.
                                                                                                                          	ClickFeedbackItems []types.ClickFeedback
                                                                                                                          
                                                                                                                          	// Provides Amazon Kendra with relevant or not relevant feedback for whether a
                                                                                                                          	// particular item was relevant to the search.
                                                                                                                          	RelevanceFeedbackItems []types.RelevanceFeedback
                                                                                                                          }

                                                                                                                          type SubmitFeedbackOutput

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

                                                                                                                          type TagResourceInput

                                                                                                                          type TagResourceInput struct {
                                                                                                                          
                                                                                                                          	// The Amazon Resource Name (ARN) of the index, FAQ, or data source to tag.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	ResourceARN *string
                                                                                                                          
                                                                                                                          	// A list of tag keys to add to the index, FAQ, or data source. If a tag already
                                                                                                                          	// exists, the existing value is replaced with the new value.
                                                                                                                          	//
                                                                                                                          	// 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 index, FAQ, or data source to remove the
                                                                                                                          	// tag from.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	ResourceARN *string
                                                                                                                          
                                                                                                                          	// A list of tag keys to remove from the index, FAQ, or data source. If a tag key
                                                                                                                          	// does not exist on the resource, it is ignored.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	TagKeys []string
                                                                                                                          }

                                                                                                                          type UntagResourceOutput

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

                                                                                                                          type UpdateDataSourceInput

                                                                                                                          type UpdateDataSourceInput struct {
                                                                                                                          
                                                                                                                          	// The unique identifier of the data source to update.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	Id *string
                                                                                                                          
                                                                                                                          	// The identifier of the index that contains the data source to update.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	IndexId *string
                                                                                                                          
                                                                                                                          	// Configuration information for a Amazon Kendra data source.
                                                                                                                          	Configuration *types.DataSourceConfiguration
                                                                                                                          
                                                                                                                          	// The new description for the data source.
                                                                                                                          	Description *string
                                                                                                                          
                                                                                                                          	// The name of the data source to update. The name of the data source can't be
                                                                                                                          	// updated. To rename a data source you must delete the data source and re-create
                                                                                                                          	// it.
                                                                                                                          	Name *string
                                                                                                                          
                                                                                                                          	// The Amazon Resource Name (ARN) of the new role to use when the data source is
                                                                                                                          	// accessing resources on your behalf.
                                                                                                                          	RoleArn *string
                                                                                                                          
                                                                                                                          	// The new update schedule for the data source.
                                                                                                                          	Schedule *string
                                                                                                                          }

                                                                                                                          type UpdateDataSourceOutput

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

                                                                                                                          type UpdateIndexInput

                                                                                                                          type UpdateIndexInput struct {
                                                                                                                          
                                                                                                                          	// The identifier of the index to update.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	Id *string
                                                                                                                          
                                                                                                                          	// Sets the number of addtional storage and query capacity units that should be
                                                                                                                          	// used by the index. You can change the capacity of the index up to 5 times per
                                                                                                                          	// day. If you are using extra storage units, you can't reduce the storage capacity
                                                                                                                          	// below that required to meet the storage needs for your index.
                                                                                                                          	CapacityUnits *types.CapacityUnitsConfiguration
                                                                                                                          
                                                                                                                          	// A new description for the index.
                                                                                                                          	Description *string
                                                                                                                          
                                                                                                                          	// The document metadata to update.
                                                                                                                          	DocumentMetadataConfigurationUpdates []types.DocumentMetadataConfiguration
                                                                                                                          
                                                                                                                          	// The name of the index to update.
                                                                                                                          	Name *string
                                                                                                                          
                                                                                                                          	// A new IAM role that gives Amazon Kendra permission to access your Amazon
                                                                                                                          	// CloudWatch logs.
                                                                                                                          	RoleArn *string
                                                                                                                          
                                                                                                                          	// The user user token context policy.
                                                                                                                          	UserContextPolicy types.UserContextPolicy
                                                                                                                          
                                                                                                                          	// The user token configuration.
                                                                                                                          	UserTokenConfigurations []types.UserTokenConfiguration
                                                                                                                          }

                                                                                                                          type UpdateIndexOutput

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

                                                                                                                          type UpdateThesaurusInput

                                                                                                                          type UpdateThesaurusInput struct {
                                                                                                                          
                                                                                                                          	// The identifier of the thesaurus to update.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	Id *string
                                                                                                                          
                                                                                                                          	// The identifier of the index associated with the thesaurus to update.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	IndexId *string
                                                                                                                          
                                                                                                                          	// The updated description of the thesaurus.
                                                                                                                          	Description *string
                                                                                                                          
                                                                                                                          	// The updated name of the thesaurus.
                                                                                                                          	Name *string
                                                                                                                          
                                                                                                                          	// The updated role ARN of the thesaurus.
                                                                                                                          	RoleArn *string
                                                                                                                          
                                                                                                                          	// Information required to find a specific file in an Amazon S3 bucket.
                                                                                                                          	SourceS3Path *types.S3Path
                                                                                                                          }

                                                                                                                          type UpdateThesaurusOutput

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

                                                                                                                          Directories

                                                                                                                          Path Synopsis
                                                                                                                          internal