Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessControlListConfiguration

type AccessControlListConfiguration struct {

	// Path to the AWS S3 bucket that contains the ACL files.
	KeyPath *string
}

    Access Control List files for the documents in a data source. For the format of the file, see Access control for S3 data sources (https://docs.aws.amazon.com/kendra/latest/dg/s3-acl.html).

    type AccessDeniedException

    type AccessDeniedException struct {
    	Message *string
    }

    func (*AccessDeniedException) Error

    func (e *AccessDeniedException) Error() string

    func (*AccessDeniedException) ErrorCode

    func (e *AccessDeniedException) ErrorCode() string

    func (*AccessDeniedException) ErrorFault

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

    func (*AccessDeniedException) ErrorMessage

    func (e *AccessDeniedException) ErrorMessage() string

    type AclConfiguration

    type AclConfiguration struct {
    
    	// A list of groups, separated by semi-colons, that filters a query response based
    	// on user context. The document is only returned to users that are in one of the
    	// groups specified in the UserContext field of the Query operation.
    	//
    	// This member is required.
    	AllowedGroupsColumnName *string
    }

      Provides information about the column that should be used for filtering the query response by groups.

      type AdditionalResultAttribute

      type AdditionalResultAttribute struct {
      
      	// The key that identifies the attribute.
      	//
      	// This member is required.
      	Key *string
      
      	// An object that contains the attribute value.
      	//
      	// This member is required.
      	Value *AdditionalResultAttributeValue
      
      	// The data type of the Value property.
      	//
      	// This member is required.
      	ValueType AdditionalResultAttributeValueType
      }

        An attribute returned from an index query.

        type AdditionalResultAttributeValue

        type AdditionalResultAttributeValue struct {
        
        	// The text associated with the attribute and information about the highlight to
        	// apply to the text.
        	TextWithHighlightsValue *TextWithHighlights
        }

          An attribute returned with a document from a search.

          type AdditionalResultAttributeValueType

          type AdditionalResultAttributeValueType string
          const (
          	AdditionalResultAttributeValueTypeTextWithHighlightsValue AdditionalResultAttributeValueType = "TEXT_WITH_HIGHLIGHTS_VALUE"
          )

            Enum values for AdditionalResultAttributeValueType

            func (AdditionalResultAttributeValueType) Values

              Values returns all known values for AdditionalResultAttributeValueType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

              type AttributeFilter

              type AttributeFilter struct {
              
              	// Performs a logical AND operation on all supplied filters.
              	AndAllFilters []AttributeFilter
              
              	// Returns true when a document contains all of the specified document attributes.
              	// This filter is only applicable to StringListValue metadata.
              	ContainsAll *DocumentAttribute
              
              	// Returns true when a document contains any of the specified document attributes.
              	// This filter is only applicable to StringListValue metadata.
              	ContainsAny *DocumentAttribute
              
              	// Performs an equals operation on two document attributes.
              	EqualsTo *DocumentAttribute
              
              	// Performs a greater than operation on two document attributes. Use with a
              	// document attribute of type Integer or Long.
              	GreaterThan *DocumentAttribute
              
              	// Performs a greater or equals than operation on two document attributes. Use with
              	// a document attribute of type Integer or Long.
              	GreaterThanOrEquals *DocumentAttribute
              
              	// Performs a less than operation on two document attributes. Use with a document
              	// attribute of type Integer or Long.
              	LessThan *DocumentAttribute
              
              	// Performs a less than or equals operation on two document attributes. Use with a
              	// document attribute of type Integer or Long.
              	LessThanOrEquals *DocumentAttribute
              
              	// Performs a logical NOT operation on all supplied filters.
              	NotFilter *AttributeFilter
              
              	// Performs a logical OR operation on all supplied filters.
              	OrAllFilters []AttributeFilter
              }

                Provides filtering the query results based on document attributes. When you use the AndAllFilters or OrAllFilters, filters you can use 2 layers under the first attribute filter. For example, you can use:

                If you use more than 2 layers, you receive a ValidationException exception with the message "AttributeFilter cannot have a depth of more than 2."

                type BatchDeleteDocumentResponseFailedDocument

                type BatchDeleteDocumentResponseFailedDocument struct {
                
                	// The error code for why the document couldn't be removed from the index.
                	ErrorCode ErrorCode
                
                	// An explanation for why the document couldn't be removed from the index.
                	ErrorMessage *string
                
                	// The identifier of the document that couldn't be removed from the index.
                	Id *string
                }

                  Provides information about documents that could not be removed from an index by the BatchDeleteDocument operation.

                  type BatchPutDocumentResponseFailedDocument

                  type BatchPutDocumentResponseFailedDocument struct {
                  
                  	// The type of error that caused the document to fail to be indexed.
                  	ErrorCode ErrorCode
                  
                  	// A description of the reason why the document could not be indexed.
                  	ErrorMessage *string
                  
                  	// The unique identifier of the document.
                  	Id *string
                  }

                    Provides information about a document that could not be indexed.

                    type CapacityUnitsConfiguration

                    type CapacityUnitsConfiguration struct {
                    
                    	// The amount of extra query capacity for an index. Each capacity unit provides 0.5
                    	// queries per second and 40,000 queries per day.
                    	//
                    	// This member is required.
                    	QueryCapacityUnits *int32
                    
                    	// The amount of extra storage capacity for an index. Each capacity unit provides
                    	// 150 Gb of storage space or 500,000 documents, whichever is reached first.
                    	//
                    	// This member is required.
                    	StorageCapacityUnits *int32
                    }

                      Specifies capacity units configured for your index. You can add and remove capacity units to tune an index to your requirements.

                      type ClickFeedback

                      type ClickFeedback struct {
                      
                      	// The Unix timestamp of the date and time that the result was clicked.
                      	//
                      	// This member is required.
                      	ClickTime *time.Time
                      
                      	// The unique identifier of the search result that was clicked.
                      	//
                      	// This member is required.
                      	ResultId *string
                      }

                        Gathers information about when a particular result was clicked by a user. Your application uses the SubmitFeedback operation to provide click information.

                        type ColumnConfiguration

                        type ColumnConfiguration struct {
                        
                        	// One to five columns that indicate when a document in the database has changed.
                        	//
                        	// This member is required.
                        	ChangeDetectingColumns []string
                        
                        	// The column that contains the contents of the document.
                        	//
                        	// This member is required.
                        	DocumentDataColumnName *string
                        
                        	// The column that provides the document's unique identifier.
                        	//
                        	// This member is required.
                        	DocumentIdColumnName *string
                        
                        	// The column that contains the title of the document.
                        	DocumentTitleColumnName *string
                        
                        	// An array of objects that map database column names to the corresponding fields
                        	// in an index. You must first create the fields in the index using the UpdateIndex
                        	// operation.
                        	FieldMappings []DataSourceToIndexFieldMapping
                        }

                          Provides information about how Amazon Kendra should use the columns of a database in an index.

                          type ConflictException

                          type ConflictException struct {
                          	Message *string
                          }

                          func (*ConflictException) Error

                          func (e *ConflictException) Error() string

                          func (*ConflictException) ErrorCode

                          func (e *ConflictException) ErrorCode() string

                          func (*ConflictException) ErrorFault

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

                          func (*ConflictException) ErrorMessage

                          func (e *ConflictException) ErrorMessage() string

                          type ConfluenceAttachmentConfiguration

                          type ConfluenceAttachmentConfiguration struct {
                          
                          	// Defines how attachment metadata fields should be mapped to index fields. Before
                          	// you can map a field, you must first create an index field with a matching type
                          	// using the console or the UpdateIndex operation. If you specify the
                          	// AttachentFieldMappings parameter, you must specify at least one field mapping.
                          	AttachmentFieldMappings []ConfluenceAttachmentToIndexFieldMapping
                          
                          	// Indicates whether Amazon Kendra indexes attachments to the pages and blogs in
                          	// the Confluence data source.
                          	CrawlAttachments bool
                          }

                            Specifies the attachment settings for the Confluence data source. Attachment settings are optional, if you don't specify settings attachments, Amazon Kendra won't index them.

                            type ConfluenceAttachmentFieldName

                            type ConfluenceAttachmentFieldName string
                            const (
                            	ConfluenceAttachmentFieldNameAuthor      ConfluenceAttachmentFieldName = "AUTHOR"
                            	ConfluenceAttachmentFieldNameContentType ConfluenceAttachmentFieldName = "CONTENT_TYPE"
                            	ConfluenceAttachmentFieldNameCreatedDate ConfluenceAttachmentFieldName = "CREATED_DATE"
                            	ConfluenceAttachmentFieldNameDisplayUrl  ConfluenceAttachmentFieldName = "DISPLAY_URL"
                            	ConfluenceAttachmentFieldNameFileSize    ConfluenceAttachmentFieldName = "FILE_SIZE"
                            	ConfluenceAttachmentFieldNameItemType    ConfluenceAttachmentFieldName = "ITEM_TYPE"
                            	ConfluenceAttachmentFieldNameParentId    ConfluenceAttachmentFieldName = "PARENT_ID"
                            	ConfluenceAttachmentFieldNameSpaceKey    ConfluenceAttachmentFieldName = "SPACE_KEY"
                            	ConfluenceAttachmentFieldNameSpaceName   ConfluenceAttachmentFieldName = "SPACE_NAME"
                            	ConfluenceAttachmentFieldNameUrl         ConfluenceAttachmentFieldName = "URL"
                            	ConfluenceAttachmentFieldNameVersion     ConfluenceAttachmentFieldName = "VERSION"
                            )

                              Enum values for ConfluenceAttachmentFieldName

                              func (ConfluenceAttachmentFieldName) Values

                                Values returns all known values for ConfluenceAttachmentFieldName. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                type ConfluenceAttachmentToIndexFieldMapping

                                type ConfluenceAttachmentToIndexFieldMapping struct {
                                
                                	// The name of the field in the data source. You must first create the index field
                                	// using the operation.
                                	DataSourceFieldName ConfluenceAttachmentFieldName
                                
                                	// The format for date fields in the data source. If the field specified in
                                	// DataSourceFieldName is a date field you must specify the date format. If the
                                	// field is not a date field, an exception is thrown.
                                	DateFieldFormat *string
                                
                                	// The name of the index field to map to the Confluence data source field. The
                                	// index field type must match the Confluence field type.
                                	IndexFieldName *string
                                }

                                  Defines the mapping between a field in the Confluence data source to a Amazon Kendra index field. You must first create the index field using the operation.

                                  type ConfluenceBlogConfiguration

                                  type ConfluenceBlogConfiguration struct {
                                  
                                  	// Defines how blog metadata fields should be mapped to index fields. Before you
                                  	// can map a field, you must first create an index field with a matching type using
                                  	// the console or the UpdateIndex operation. If you specify the BlogFieldMappings
                                  	// parameter, you must specify at least one field mapping.
                                  	BlogFieldMappings []ConfluenceBlogToIndexFieldMapping
                                  }

                                    Specifies the blog settings for the Confluence data source. Blogs are always indexed unless filtered from the index by the ExclusionPatterns or InclusionPatterns fields in the data type.

                                    type ConfluenceBlogFieldName

                                    type ConfluenceBlogFieldName string
                                    const (
                                    	ConfluenceBlogFieldNameAuthor      ConfluenceBlogFieldName = "AUTHOR"
                                    	ConfluenceBlogFieldNameDisplayUrl  ConfluenceBlogFieldName = "DISPLAY_URL"
                                    	ConfluenceBlogFieldNameItemType    ConfluenceBlogFieldName = "ITEM_TYPE"
                                    	ConfluenceBlogFieldNameLabels      ConfluenceBlogFieldName = "LABELS"
                                    	ConfluenceBlogFieldNamePublishDate ConfluenceBlogFieldName = "PUBLISH_DATE"
                                    	ConfluenceBlogFieldNameSpaceKey    ConfluenceBlogFieldName = "SPACE_KEY"
                                    	ConfluenceBlogFieldNameSpaceName   ConfluenceBlogFieldName = "SPACE_NAME"
                                    	ConfluenceBlogFieldNameUrl         ConfluenceBlogFieldName = "URL"
                                    	ConfluenceBlogFieldNameVersion     ConfluenceBlogFieldName = "VERSION"
                                    )

                                      Enum values for ConfluenceBlogFieldName

                                      func (ConfluenceBlogFieldName) Values

                                        Values returns all known values for ConfluenceBlogFieldName. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                        type ConfluenceBlogToIndexFieldMapping

                                        type ConfluenceBlogToIndexFieldMapping struct {
                                        
                                        	// The name of the field in the data source.
                                        	DataSourceFieldName ConfluenceBlogFieldName
                                        
                                        	// The format for date fields in the data source. If the field specified in
                                        	// DataSourceFieldName is a date field you must specify the date format. If the
                                        	// field is not a date field, an exception is thrown.
                                        	DateFieldFormat *string
                                        
                                        	// The name of the index field to map to the Confluence data source field. The
                                        	// index field type must match the Confluence field type.
                                        	IndexFieldName *string
                                        }

                                          Defines the mapping between a blog field in the Confluence data source to a Amazon Kendra index field. You must first create the index field using the operation.

                                          type ConfluenceConfiguration

                                          type ConfluenceConfiguration struct {
                                          
                                          	// The Amazon Resource Name (ARN) of an AWS Secrets Manager secret that contains
                                          	// the key/value pairs required to connect to your Confluence server. The secret
                                          	// must contain a JSON structure with the following keys:
                                          	//
                                          	// * username - The user
                                          	// name or email address of a user with administrative privileges for the
                                          	// Confluence server.
                                          	//
                                          	// * password - The password associated with the user logging
                                          	// in to the Confluence server.
                                          	//
                                          	// This member is required.
                                          	SecretArn *string
                                          
                                          	// The URL of your Confluence instance. Use the full URL of the server. For
                                          	// example, https://server.example.com:port/. You can also use an IP address, for
                                          	// example, https://192.168.1.113/.
                                          	//
                                          	// This member is required.
                                          	ServerUrl *string
                                          
                                          	// Specifies the version of the Confluence installation that you are connecting to.
                                          	//
                                          	// This member is required.
                                          	Version ConfluenceVersion
                                          
                                          	// Specifies configuration information for indexing attachments to Confluence blogs
                                          	// and pages.
                                          	AttachmentConfiguration *ConfluenceAttachmentConfiguration
                                          
                                          	// Specifies configuration information for indexing Confluence blogs.
                                          	BlogConfiguration *ConfluenceBlogConfiguration
                                          
                                          	// A list of regular expression patterns that apply to a URL on the Confluence
                                          	// server. An exclusion pattern can apply to a blog post, a page, a space, or an
                                          	// attachment. Items that match the pattern are excluded from the index. Items that
                                          	// don't match the pattern are included in the index. If a item matches both an
                                          	// exclusion pattern and an inclusion pattern, the item isn't included in the
                                          	// index.
                                          	ExclusionPatterns []string
                                          
                                          	// A list of regular expression patterns that apply to a URL on the Confluence
                                          	// server. An inclusion pattern can apply to a blog post, a page, a space, or an
                                          	// attachment. Items that match the patterns are included in the index. Items that
                                          	// don't match the pattern are excluded from the index. If an item matches both an
                                          	// inclusion pattern and an exclusion pattern, the item isn't included in the
                                          	// index.
                                          	InclusionPatterns []string
                                          
                                          	// Specifies configuration information for indexing Confluence pages.
                                          	PageConfiguration *ConfluencePageConfiguration
                                          
                                          	// Specifies configuration information for indexing Confluence spaces.
                                          	SpaceConfiguration *ConfluenceSpaceConfiguration
                                          
                                          	// Specifies the information for connecting to an Amazon VPC.
                                          	VpcConfiguration *DataSourceVpcConfiguration
                                          }

                                            Provides configuration information for data sources that connect to Confluence.

                                            type ConfluencePageConfiguration

                                            type ConfluencePageConfiguration struct {
                                            
                                            	// Defines how page metadata fields should be mapped to index fields. Before you
                                            	// can map a field, you must first create an index field with a matching type using
                                            	// the console or the UpdateIndex operation. If you specify the PageFieldMappings
                                            	// parameter, you must specify at least one field mapping.
                                            	PageFieldMappings []ConfluencePageToIndexFieldMapping
                                            }

                                              Specifies the page settings for the Confluence data source.

                                              type ConfluencePageFieldName

                                              type ConfluencePageFieldName string
                                              const (
                                              	ConfluencePageFieldNameAuthor        ConfluencePageFieldName = "AUTHOR"
                                              	ConfluencePageFieldNameContentStatus ConfluencePageFieldName = "CONTENT_STATUS"
                                              	ConfluencePageFieldNameCreatedDate   ConfluencePageFieldName = "CREATED_DATE"
                                              	ConfluencePageFieldNameDisplayUrl    ConfluencePageFieldName = "DISPLAY_URL"
                                              	ConfluencePageFieldNameItemType      ConfluencePageFieldName = "ITEM_TYPE"
                                              	ConfluencePageFieldNameLabels        ConfluencePageFieldName = "LABELS"
                                              	ConfluencePageFieldNameModifiedDate  ConfluencePageFieldName = "MODIFIED_DATE"
                                              	ConfluencePageFieldNameParentId      ConfluencePageFieldName = "PARENT_ID"
                                              	ConfluencePageFieldNameSpaceKey      ConfluencePageFieldName = "SPACE_KEY"
                                              	ConfluencePageFieldNameSpaceName     ConfluencePageFieldName = "SPACE_NAME"
                                              	ConfluencePageFieldNameUrl           ConfluencePageFieldName = "URL"
                                              	ConfluencePageFieldNameVersion       ConfluencePageFieldName = "VERSION"
                                              )

                                                Enum values for ConfluencePageFieldName

                                                func (ConfluencePageFieldName) Values

                                                  Values returns all known values for ConfluencePageFieldName. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                  type ConfluencePageToIndexFieldMapping

                                                  type ConfluencePageToIndexFieldMapping struct {
                                                  
                                                  	// The name of the field in the data source.
                                                  	DataSourceFieldName ConfluencePageFieldName
                                                  
                                                  	// The format for date fields in the data source. If the field specified in
                                                  	// DataSourceFieldName is a date field you must specify the date format. If the
                                                  	// field is not a date field, an exception is thrown.
                                                  	DateFieldFormat *string
                                                  
                                                  	// The name of the index field to map to the Confluence data source field. The
                                                  	// index field type must match the Confluence field type.
                                                  	IndexFieldName *string
                                                  }

                                                    Defines the mapping between a field in the Confluence data source to a Amazon Kendra index field. You must first create the index field using the operation.

                                                    type ConfluenceSpaceConfiguration

                                                    type ConfluenceSpaceConfiguration struct {
                                                    
                                                    	// Specifies whether Amazon Kendra should index archived spaces.
                                                    	CrawlArchivedSpaces bool
                                                    
                                                    	// Specifies whether Amazon Kendra should index personal spaces. Users can add
                                                    	// restrictions to items in personal spaces. If personal spaces are indexed,
                                                    	// queries without user context information may return restricted items from a
                                                    	// personal space in their results. For more information, see Filtering on user
                                                    	// context (https://docs.aws.amazon.com/kendra/latest/dg/user-context-filter.html).
                                                    	CrawlPersonalSpaces bool
                                                    
                                                    	// A list of space keys of Confluence spaces. If you include a key, the blogs,
                                                    	// documents, and attachments in the space are not indexed. If a space is in both
                                                    	// the ExcludeSpaces and the IncludeSpaces list, the space is excluded.
                                                    	ExcludeSpaces []string
                                                    
                                                    	// A list of space keys for Confluence spaces. If you include a key, the blogs,
                                                    	// documents, and attachments in the space are indexed. Spaces that aren't in the
                                                    	// list aren't indexed. A space in the list must exist. Otherwise, Amazon Kendra
                                                    	// logs an error when the data source is synchronized. If a space is in both the
                                                    	// IncludeSpaces and the ExcludeSpaces list, the space is excluded.
                                                    	IncludeSpaces []string
                                                    
                                                    	// Defines how space metadata fields should be mapped to index fields. Before you
                                                    	// can map a field, you must first create an index field with a matching type using
                                                    	// the console or the UpdateIndex operation. If you specify the SpaceFieldMappings
                                                    	// parameter, you must specify at least one field mapping.
                                                    	SpaceFieldMappings []ConfluenceSpaceToIndexFieldMapping
                                                    }

                                                      Specifies the configuration for indexing Confluence spaces.

                                                      type ConfluenceSpaceFieldName

                                                      type ConfluenceSpaceFieldName string
                                                      const (
                                                      	ConfluenceSpaceFieldNameDisplayUrl ConfluenceSpaceFieldName = "DISPLAY_URL"
                                                      	ConfluenceSpaceFieldNameItemType   ConfluenceSpaceFieldName = "ITEM_TYPE"
                                                      	ConfluenceSpaceFieldNameSpaceKey   ConfluenceSpaceFieldName = "SPACE_KEY"
                                                      	ConfluenceSpaceFieldNameUrl        ConfluenceSpaceFieldName = "URL"
                                                      )

                                                        Enum values for ConfluenceSpaceFieldName

                                                        func (ConfluenceSpaceFieldName) Values

                                                          Values returns all known values for ConfluenceSpaceFieldName. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                          type ConfluenceSpaceToIndexFieldMapping

                                                          type ConfluenceSpaceToIndexFieldMapping struct {
                                                          
                                                          	// The name of the field in the data source.
                                                          	DataSourceFieldName ConfluenceSpaceFieldName
                                                          
                                                          	// The format for date fields in the data source. If the field specified in
                                                          	// DataSourceFieldName is a date field you must specify the date format. If the
                                                          	// field is not a date field, an exception is thrown.
                                                          	DateFieldFormat *string
                                                          
                                                          	// The name of the index field to map to the Confluence data source field. The
                                                          	// index field type must match the Confluence field type.
                                                          	IndexFieldName *string
                                                          }

                                                            Defines the mapping between a field in the Confluence data source to a Amazon Kendra index field. You must first create the index field using the operation.

                                                            type ConfluenceVersion

                                                            type ConfluenceVersion string
                                                            const (
                                                            	ConfluenceVersionCloud  ConfluenceVersion = "CLOUD"
                                                            	ConfluenceVersionServer ConfluenceVersion = "SERVER"
                                                            )

                                                              Enum values for ConfluenceVersion

                                                              func (ConfluenceVersion) Values

                                                                Values returns all known values for ConfluenceVersion. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                type ConnectionConfiguration

                                                                type ConnectionConfiguration struct {
                                                                
                                                                	// The name of the host for the database. Can be either a string
                                                                	// (host.subdomain.domain.tld) or an IPv4 or IPv6 address.
                                                                	//
                                                                	// This member is required.
                                                                	DatabaseHost *string
                                                                
                                                                	// The name of the database containing the document data.
                                                                	//
                                                                	// This member is required.
                                                                	DatabaseName *string
                                                                
                                                                	// The port that the database uses for connections.
                                                                	//
                                                                	// This member is required.
                                                                	DatabasePort *int32
                                                                
                                                                	// The Amazon Resource Name (ARN) of credentials stored in AWS Secrets Manager. The
                                                                	// credentials should be a user/password pair. For more information, see Using a
                                                                	// Database Data Source
                                                                	// (https://docs.aws.amazon.com/kendra/latest/dg/data-source-database.html). For
                                                                	// more information about AWS Secrets Manager, see  What Is AWS Secrets Manager
                                                                	// (https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) in the
                                                                	// AWS Secrets Manager user guide.
                                                                	//
                                                                	// This member is required.
                                                                	SecretArn *string
                                                                
                                                                	// The name of the table that contains the document data.
                                                                	//
                                                                	// This member is required.
                                                                	TableName *string
                                                                }

                                                                  Provides the information necessary to connect to a database.

                                                                  type ContentType

                                                                  type ContentType string
                                                                  const (
                                                                  	ContentTypePdf       ContentType = "PDF"
                                                                  	ContentTypeHtml      ContentType = "HTML"
                                                                  	ContentTypeMsWord    ContentType = "MS_WORD"
                                                                  	ContentTypePlainText ContentType = "PLAIN_TEXT"
                                                                  	ContentTypePpt       ContentType = "PPT"
                                                                  )

                                                                    Enum values for ContentType

                                                                    func (ContentType) Values

                                                                    func (ContentType) Values() []ContentType

                                                                      Values returns all known values for ContentType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                      type DataSourceConfiguration

                                                                      type DataSourceConfiguration struct {
                                                                      
                                                                      	// Provides configuration information for connecting to a Confluence data source.
                                                                      	ConfluenceConfiguration *ConfluenceConfiguration
                                                                      
                                                                      	// Provides information necessary to create a data source connector for a database.
                                                                      	DatabaseConfiguration *DatabaseConfiguration
                                                                      
                                                                      	// Provides configuration for data sources that connect to Google Drive.
                                                                      	GoogleDriveConfiguration *GoogleDriveConfiguration
                                                                      
                                                                      	// Provides configuration for data sources that connect to Microsoft OneDrive.
                                                                      	OneDriveConfiguration *OneDriveConfiguration
                                                                      
                                                                      	// Provides information to create a data source connector for a document repository
                                                                      	// in an Amazon S3 bucket.
                                                                      	S3Configuration *S3DataSourceConfiguration
                                                                      
                                                                      	// Provides configuration information for data sources that connect to a Salesforce
                                                                      	// site.
                                                                      	SalesforceConfiguration *SalesforceConfiguration
                                                                      
                                                                      	// Provides configuration for data sources that connect to ServiceNow instances.
                                                                      	ServiceNowConfiguration *ServiceNowConfiguration
                                                                      
                                                                      	// Provides information necessary to create a data source connector for a Microsoft
                                                                      	// SharePoint site.
                                                                      	SharePointConfiguration *SharePointConfiguration
                                                                      }

                                                                        Configuration information for a Amazon Kendra data source.

                                                                        type DataSourceStatus

                                                                        type DataSourceStatus string
                                                                        const (
                                                                        	DataSourceStatusCreating DataSourceStatus = "CREATING"
                                                                        	DataSourceStatusDeleting DataSourceStatus = "DELETING"
                                                                        	DataSourceStatusFailed   DataSourceStatus = "FAILED"
                                                                        	DataSourceStatusUpdating DataSourceStatus = "UPDATING"
                                                                        	DataSourceStatusActive   DataSourceStatus = "ACTIVE"
                                                                        )

                                                                          Enum values for DataSourceStatus

                                                                          func (DataSourceStatus) Values

                                                                            Values returns all known values for DataSourceStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                            type DataSourceSummary

                                                                            type DataSourceSummary struct {
                                                                            
                                                                            	// The UNIX datetime that the data source was created.
                                                                            	CreatedAt *time.Time
                                                                            
                                                                            	// The unique identifier for the data source.
                                                                            	Id *string
                                                                            
                                                                            	// The name of the data source.
                                                                            	Name *string
                                                                            
                                                                            	// The status of the data source. When the status is ATIVE the data source is ready
                                                                            	// to use.
                                                                            	Status DataSourceStatus
                                                                            
                                                                            	// The type of the data source.
                                                                            	Type DataSourceType
                                                                            
                                                                            	// The UNIX datetime that the data source was lasted updated.
                                                                            	UpdatedAt *time.Time
                                                                            }

                                                                              Summary information for a Amazon Kendra data source. Returned in a call to .

                                                                              type DataSourceSyncJob

                                                                              type DataSourceSyncJob struct {
                                                                              
                                                                              	// If the reason that the synchronization failed is due to an error with the
                                                                              	// underlying data source, this field contains a code that identifies the error.
                                                                              	DataSourceErrorCode *string
                                                                              
                                                                              	// The UNIX datetime that the synchronization job was completed.
                                                                              	EndTime *time.Time
                                                                              
                                                                              	// If the Status field is set to FAILED, the ErrorCode field contains a the reason
                                                                              	// that the synchronization failed.
                                                                              	ErrorCode ErrorCode
                                                                              
                                                                              	// If the Status field is set to ERROR, the ErrorMessage field contains a
                                                                              	// description of the error that caused the synchronization to fail.
                                                                              	ErrorMessage *string
                                                                              
                                                                              	// A unique identifier for the synchronization job.
                                                                              	ExecutionId *string
                                                                              
                                                                              	// Maps a batch delete document request to a specific data source sync job. This is
                                                                              	// optional and should only be supplied when documents are deleted by a data source
                                                                              	// connector.
                                                                              	Metrics *DataSourceSyncJobMetrics
                                                                              
                                                                              	// The UNIX datetime that the synchronization job was started.
                                                                              	StartTime *time.Time
                                                                              
                                                                              	// The execution status of the synchronization job. When the Status field is set to
                                                                              	// SUCCEEDED, the synchronization job is done. If the status code is set to FAILED,
                                                                              	// the ErrorCode and ErrorMessage fields give you the reason for the failure.
                                                                              	Status DataSourceSyncJobStatus
                                                                              }

                                                                                Provides information about a synchronization job.

                                                                                type DataSourceSyncJobMetricTarget

                                                                                type DataSourceSyncJobMetricTarget struct {
                                                                                
                                                                                	// The ID of the data source that is running the sync job.
                                                                                	//
                                                                                	// This member is required.
                                                                                	DataSourceId *string
                                                                                
                                                                                	// The ID of the sync job that is running on the data source.
                                                                                	//
                                                                                	// This member is required.
                                                                                	DataSourceSyncJobId *string
                                                                                }

                                                                                  Maps a particular data source sync job to a particular data source.

                                                                                  type DataSourceSyncJobMetrics

                                                                                  type DataSourceSyncJobMetrics struct {
                                                                                  
                                                                                  	// The number of documents added from the data source up to now in the data source
                                                                                  	// sync.
                                                                                  	DocumentsAdded *string
                                                                                  
                                                                                  	// The number of documents deleted from the data source up to now in the data
                                                                                  	// source sync run.
                                                                                  	DocumentsDeleted *string
                                                                                  
                                                                                  	// The number of documents that failed to sync from the data source up to now in
                                                                                  	// the data source sync run.
                                                                                  	DocumentsFailed *string
                                                                                  
                                                                                  	// The number of documents modified in the data source up to now in the data source
                                                                                  	// sync run.
                                                                                  	DocumentsModified *string
                                                                                  
                                                                                  	// The current number of documents crawled by the current sync job in the data
                                                                                  	// source.
                                                                                  	DocumentsScanned *string
                                                                                  }

                                                                                    Maps a batch delete document request to a specific data source sync job. This is optional and should only be supplied when documents are deleted by a data source connector.

                                                                                    type DataSourceSyncJobStatus

                                                                                    type DataSourceSyncJobStatus string
                                                                                    const (
                                                                                    	DataSourceSyncJobStatusFailed          DataSourceSyncJobStatus = "FAILED"
                                                                                    	DataSourceSyncJobStatusSucceeded       DataSourceSyncJobStatus = "SUCCEEDED"
                                                                                    	DataSourceSyncJobStatusSyncing         DataSourceSyncJobStatus = "SYNCING"
                                                                                    	DataSourceSyncJobStatusIncomplete      DataSourceSyncJobStatus = "INCOMPLETE"
                                                                                    	DataSourceSyncJobStatusStopping        DataSourceSyncJobStatus = "STOPPING"
                                                                                    	DataSourceSyncJobStatusAborted         DataSourceSyncJobStatus = "ABORTED"
                                                                                    	DataSourceSyncJobStatusSyncingIndexing DataSourceSyncJobStatus = "SYNCING_INDEXING"
                                                                                    )

                                                                                      Enum values for DataSourceSyncJobStatus

                                                                                      func (DataSourceSyncJobStatus) Values

                                                                                        Values returns all known values for DataSourceSyncJobStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                        type DataSourceToIndexFieldMapping

                                                                                        type DataSourceToIndexFieldMapping struct {
                                                                                        
                                                                                        	// The name of the column or attribute in the data source.
                                                                                        	//
                                                                                        	// This member is required.
                                                                                        	DataSourceFieldName *string
                                                                                        
                                                                                        	// The name of the field in the index.
                                                                                        	//
                                                                                        	// This member is required.
                                                                                        	IndexFieldName *string
                                                                                        
                                                                                        	// The type of data stored in the column or attribute.
                                                                                        	DateFieldFormat *string
                                                                                        }

                                                                                          Maps a column or attribute in the data source to an index field. You must first create the fields in the index using the UpdateIndex operation.

                                                                                          type DataSourceType

                                                                                          type DataSourceType string
                                                                                          const (
                                                                                          	DataSourceTypeS3          DataSourceType = "S3"
                                                                                          	DataSourceTypeSharepoint  DataSourceType = "SHAREPOINT"
                                                                                          	DataSourceTypeDatabase    DataSourceType = "DATABASE"
                                                                                          	DataSourceTypeSalesforce  DataSourceType = "SALESFORCE"
                                                                                          	DataSourceTypeOnedrive    DataSourceType = "ONEDRIVE"
                                                                                          	DataSourceTypeServicenow  DataSourceType = "SERVICENOW"
                                                                                          	DataSourceTypeCustom      DataSourceType = "CUSTOM"
                                                                                          	DataSourceTypeConfluence  DataSourceType = "CONFLUENCE"
                                                                                          	DataSourceTypeGoogledrive DataSourceType = "GOOGLEDRIVE"
                                                                                          )

                                                                                            Enum values for DataSourceType

                                                                                            func (DataSourceType) Values

                                                                                            func (DataSourceType) Values() []DataSourceType

                                                                                              Values returns all known values for DataSourceType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                              type DataSourceVpcConfiguration

                                                                                              type DataSourceVpcConfiguration struct {
                                                                                              
                                                                                              	// A list of identifiers of security groups within your Amazon VPC. The security
                                                                                              	// groups should enable Amazon Kendra to connect to the data source.
                                                                                              	//
                                                                                              	// This member is required.
                                                                                              	SecurityGroupIds []string
                                                                                              
                                                                                              	// A list of identifiers for subnets within your Amazon VPC. The subnets should be
                                                                                              	// able to connect to each other in the VPC, and they should have outgoing access
                                                                                              	// to the Internet through a NAT device.
                                                                                              	//
                                                                                              	// This member is required.
                                                                                              	SubnetIds []string
                                                                                              }

                                                                                                Provides information for connecting to an Amazon VPC.

                                                                                                type DatabaseConfiguration

                                                                                                type DatabaseConfiguration struct {
                                                                                                
                                                                                                	// Information about where the index should get the document information from the
                                                                                                	// database.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	ColumnConfiguration *ColumnConfiguration
                                                                                                
                                                                                                	// The information necessary to connect to a database.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	ConnectionConfiguration *ConnectionConfiguration
                                                                                                
                                                                                                	// The type of database engine that runs the database.
                                                                                                	//
                                                                                                	// This member is required.
                                                                                                	DatabaseEngineType DatabaseEngineType
                                                                                                
                                                                                                	// Information about the database column that provides information for user context
                                                                                                	// filtering.
                                                                                                	AclConfiguration *AclConfiguration
                                                                                                
                                                                                                	// Provides information about how Amazon Kendra uses quote marks around SQL
                                                                                                	// identifiers when querying a database data source.
                                                                                                	SqlConfiguration *SqlConfiguration
                                                                                                
                                                                                                	// Provides information for connecting to an Amazon VPC.
                                                                                                	VpcConfiguration *DataSourceVpcConfiguration
                                                                                                }

                                                                                                  Provides the information necessary to connect a database to an index.

                                                                                                  type DatabaseEngineType

                                                                                                  type DatabaseEngineType string
                                                                                                  const (
                                                                                                  	DatabaseEngineTypeRdsAuroraMysql      DatabaseEngineType = "RDS_AURORA_MYSQL"
                                                                                                  	DatabaseEngineTypeRdsAuroraPostgresql DatabaseEngineType = "RDS_AURORA_POSTGRESQL"
                                                                                                  	DatabaseEngineTypeRdsMysql            DatabaseEngineType = "RDS_MYSQL"
                                                                                                  	DatabaseEngineTypeRdsPostgresql       DatabaseEngineType = "RDS_POSTGRESQL"
                                                                                                  )

                                                                                                    Enum values for DatabaseEngineType

                                                                                                    func (DatabaseEngineType) Values

                                                                                                      Values returns all known values for DatabaseEngineType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                      type Document

                                                                                                      type Document struct {
                                                                                                      
                                                                                                      	// A unique identifier of the document in the index.
                                                                                                      	//
                                                                                                      	// This member is required.
                                                                                                      	Id *string
                                                                                                      
                                                                                                      	// Information to use for user context filtering.
                                                                                                      	AccessControlList []Principal
                                                                                                      
                                                                                                      	// Custom attributes to apply to the document. Use the custom attributes to provide
                                                                                                      	// additional information for searching, to provide facets for refining searches,
                                                                                                      	// and to provide additional information in the query response.
                                                                                                      	Attributes []DocumentAttribute
                                                                                                      
                                                                                                      	// The contents of the document. Documents passed to the Blob parameter must be
                                                                                                      	// base64 encoded. Your code might not need to encode the document file bytes if
                                                                                                      	// you're using an AWS SDK to call Amazon Kendra operations. If you are calling the
                                                                                                      	// Amazon Kendra endpoint directly using REST, you must base64 encode the contents
                                                                                                      	// before sending.
                                                                                                      	Blob []byte
                                                                                                      
                                                                                                      	// The file type of the document in the Blob field.
                                                                                                      	ContentType ContentType
                                                                                                      
                                                                                                      	// Information required to find a specific file in an Amazon S3 bucket.
                                                                                                      	S3Path *S3Path
                                                                                                      
                                                                                                      	// The title of the document.
                                                                                                      	Title *string
                                                                                                      }

                                                                                                        A document in an index.

                                                                                                        type DocumentAttribute

                                                                                                        type DocumentAttribute struct {
                                                                                                        
                                                                                                        	// The identifier for the attribute.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	Key *string
                                                                                                        
                                                                                                        	// The value of the attribute.
                                                                                                        	//
                                                                                                        	// This member is required.
                                                                                                        	Value DocumentAttributeValue
                                                                                                        }

                                                                                                          A custom attribute value assigned to a document.

                                                                                                          type DocumentAttributeValue

                                                                                                          type DocumentAttributeValue interface {
                                                                                                          	// contains filtered or unexported methods
                                                                                                          }

                                                                                                            The value of a custom document attribute. You can only provide one value for a custom attribute.

                                                                                                            The following types satisfy this interface:

                                                                                                            DocumentAttributeValueMemberStringValue
                                                                                                            DocumentAttributeValueMemberStringListValue
                                                                                                            DocumentAttributeValueMemberLongValue
                                                                                                            DocumentAttributeValueMemberDateValue
                                                                                                            
                                                                                                            Example (OutputUsage)
                                                                                                            Output:
                                                                                                            
                                                                                                            

                                                                                                            type DocumentAttributeValueCountPair

                                                                                                            type DocumentAttributeValueCountPair struct {
                                                                                                            
                                                                                                            	// The number of documents in the response that have the attribute value for the
                                                                                                            	// key.
                                                                                                            	Count *int32
                                                                                                            
                                                                                                            	// The value of the attribute. For example, "HR."
                                                                                                            	DocumentAttributeValue DocumentAttributeValue
                                                                                                            }

                                                                                                              Provides the count of documents that match a particular attribute when doing a faceted search.

                                                                                                              type DocumentAttributeValueMemberDateValue

                                                                                                              type DocumentAttributeValueMemberDateValue struct {
                                                                                                              	Value time.Time
                                                                                                              }

                                                                                                                A date expressed as an ISO 8601 string.

                                                                                                                type DocumentAttributeValueMemberLongValue

                                                                                                                type DocumentAttributeValueMemberLongValue struct {
                                                                                                                	Value int64
                                                                                                                }

                                                                                                                  A long integer value.

                                                                                                                  type DocumentAttributeValueMemberStringListValue

                                                                                                                  type DocumentAttributeValueMemberStringListValue struct {
                                                                                                                  	Value []string
                                                                                                                  }

                                                                                                                    A list of strings.

                                                                                                                    type DocumentAttributeValueMemberStringValue

                                                                                                                    type DocumentAttributeValueMemberStringValue struct {
                                                                                                                    	Value string
                                                                                                                    }

                                                                                                                      A string, such as "department".

                                                                                                                      type DocumentAttributeValueType

                                                                                                                      type DocumentAttributeValueType string
                                                                                                                      const (
                                                                                                                      	DocumentAttributeValueTypeStringValue     DocumentAttributeValueType = "STRING_VALUE"
                                                                                                                      	DocumentAttributeValueTypeStringListValue DocumentAttributeValueType = "STRING_LIST_VALUE"
                                                                                                                      	DocumentAttributeValueTypeLongValue       DocumentAttributeValueType = "LONG_VALUE"
                                                                                                                      	DocumentAttributeValueTypeDateValue       DocumentAttributeValueType = "DATE_VALUE"
                                                                                                                      )

                                                                                                                        Enum values for DocumentAttributeValueType

                                                                                                                        func (DocumentAttributeValueType) Values

                                                                                                                          Values returns all known values for DocumentAttributeValueType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                          type DocumentMetadataConfiguration

                                                                                                                          type DocumentMetadataConfiguration struct {
                                                                                                                          
                                                                                                                          	// The name of the index field.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	Name *string
                                                                                                                          
                                                                                                                          	// The data type of the index field.
                                                                                                                          	//
                                                                                                                          	// This member is required.
                                                                                                                          	Type DocumentAttributeValueType
                                                                                                                          
                                                                                                                          	// Provides manual tuning parameters to determine how the field affects the search
                                                                                                                          	// results.
                                                                                                                          	Relevance *Relevance
                                                                                                                          
                                                                                                                          	// Provides information about how the field is used during a search.
                                                                                                                          	Search *Search
                                                                                                                          }

                                                                                                                            Specifies the properties of a custom index field.

                                                                                                                            type DocumentsMetadataConfiguration

                                                                                                                            type DocumentsMetadataConfiguration struct {
                                                                                                                            
                                                                                                                            	// A prefix used to filter metadata configuration files in the AWS S3 bucket. The
                                                                                                                            	// S3 bucket might contain multiple metadata files. Use S3Prefix to include only
                                                                                                                            	// the desired metadata files.
                                                                                                                            	S3Prefix *string
                                                                                                                            }

                                                                                                                              Document metadata files that contain information such as the document access control information, source URI, document author, and custom attributes. Each metadata file contains metadata about a single document.

                                                                                                                              type ErrorCode

                                                                                                                              type ErrorCode string
                                                                                                                              const (
                                                                                                                              	ErrorCodeInternalError  ErrorCode = "InternalError"
                                                                                                                              	ErrorCodeInvalidRequest ErrorCode = "InvalidRequest"
                                                                                                                              )

                                                                                                                                Enum values for ErrorCode

                                                                                                                                func (ErrorCode) Values

                                                                                                                                func (ErrorCode) Values() []ErrorCode

                                                                                                                                  Values returns all known values for ErrorCode. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                  type Facet

                                                                                                                                  type Facet struct {
                                                                                                                                  
                                                                                                                                  	// The unique key for the document attribute.
                                                                                                                                  	DocumentAttributeKey *string
                                                                                                                                  }

                                                                                                                                    Information about a document attribute

                                                                                                                                    type FacetResult

                                                                                                                                    type FacetResult struct {
                                                                                                                                    
                                                                                                                                    	// The key for the facet values. This is the same as the DocumentAttributeKey
                                                                                                                                    	// provided in the query.
                                                                                                                                    	DocumentAttributeKey *string
                                                                                                                                    
                                                                                                                                    	// An array of key/value pairs, where the key is the value of the attribute and the
                                                                                                                                    	// count is the number of documents that share the key value.
                                                                                                                                    	DocumentAttributeValueCountPairs []DocumentAttributeValueCountPair
                                                                                                                                    
                                                                                                                                    	// The data type of the facet value. This is the same as the type defined for the
                                                                                                                                    	// index field when it was created.
                                                                                                                                    	DocumentAttributeValueType DocumentAttributeValueType
                                                                                                                                    }

                                                                                                                                      The facet values for the documents in the response.

                                                                                                                                      type FaqFileFormat

                                                                                                                                      type FaqFileFormat string
                                                                                                                                      const (
                                                                                                                                      	FaqFileFormatCsv           FaqFileFormat = "CSV"
                                                                                                                                      	FaqFileFormatCsvWithHeader FaqFileFormat = "CSV_WITH_HEADER"
                                                                                                                                      	FaqFileFormatJson          FaqFileFormat = "JSON"
                                                                                                                                      )

                                                                                                                                        Enum values for FaqFileFormat

                                                                                                                                        func (FaqFileFormat) Values

                                                                                                                                        func (FaqFileFormat) Values() []FaqFileFormat

                                                                                                                                          Values returns all known values for FaqFileFormat. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                          type FaqStatistics

                                                                                                                                          type FaqStatistics struct {
                                                                                                                                          
                                                                                                                                          	// The total number of FAQ questions and answers contained in the index.
                                                                                                                                          	//
                                                                                                                                          	// This member is required.
                                                                                                                                          	IndexedQuestionAnswersCount int32
                                                                                                                                          }

                                                                                                                                            Provides statistical information about the FAQ questions and answers contained in an index.

                                                                                                                                            type FaqStatus

                                                                                                                                            type FaqStatus string
                                                                                                                                            const (
                                                                                                                                            	FaqStatusCreating FaqStatus = "CREATING"
                                                                                                                                            	FaqStatusUpdating FaqStatus = "UPDATING"
                                                                                                                                            	FaqStatusActive   FaqStatus = "ACTIVE"
                                                                                                                                            	FaqStatusDeleting FaqStatus = "DELETING"
                                                                                                                                            	FaqStatusFailed   FaqStatus = "FAILED"
                                                                                                                                            )

                                                                                                                                              Enum values for FaqStatus

                                                                                                                                              func (FaqStatus) Values

                                                                                                                                              func (FaqStatus) Values() []FaqStatus

                                                                                                                                                Values returns all known values for FaqStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                type FaqSummary

                                                                                                                                                type FaqSummary struct {
                                                                                                                                                
                                                                                                                                                	// The UNIX datetime that the FAQ was added to the index.
                                                                                                                                                	CreatedAt *time.Time
                                                                                                                                                
                                                                                                                                                	// The file type used to create the FAQ.
                                                                                                                                                	FileFormat FaqFileFormat
                                                                                                                                                
                                                                                                                                                	// The unique identifier of the FAQ.
                                                                                                                                                	Id *string
                                                                                                                                                
                                                                                                                                                	// The name that you assigned the FAQ when you created or updated the FAQ.
                                                                                                                                                	Name *string
                                                                                                                                                
                                                                                                                                                	// The current status of the FAQ. When the status is ACTIVE the FAQ is ready for
                                                                                                                                                	// use.
                                                                                                                                                	Status FaqStatus
                                                                                                                                                
                                                                                                                                                	// The UNIX datetime that the FAQ was last updated.
                                                                                                                                                	UpdatedAt *time.Time
                                                                                                                                                }

                                                                                                                                                  Provides information about a frequently asked questions and answer contained in an index.

                                                                                                                                                  type GoogleDriveConfiguration

                                                                                                                                                  type GoogleDriveConfiguration struct {
                                                                                                                                                  
                                                                                                                                                  	// The Amazon Resource Name (ARN) of a AWS Secrets Manager secret that contains the
                                                                                                                                                  	// credentials required to connect to Google Drive. For more information, see Using
                                                                                                                                                  	// a Google Workspace Drive data source
                                                                                                                                                  	// (https://docs.aws.amazon.com/kendra/latest/dg/data-source-google-drive.html).
                                                                                                                                                  	//
                                                                                                                                                  	// This member is required.
                                                                                                                                                  	SecretArn *string
                                                                                                                                                  
                                                                                                                                                  	// A list of MIME types to exclude from the index. All documents matching the
                                                                                                                                                  	// specified MIME type are excluded. For a list of MIME types, see Using a Google
                                                                                                                                                  	// Workspace Drive data source
                                                                                                                                                  	// (https://docs.aws.amazon.com/kendra/latest/dg/data-source-google-drive.html).
                                                                                                                                                  	ExcludeMimeTypes []string
                                                                                                                                                  
                                                                                                                                                  	// A list of identifiers or shared drives to exclude from the index. All files and
                                                                                                                                                  	// folders stored on the shared drive are excluded.
                                                                                                                                                  	ExcludeSharedDrives []string
                                                                                                                                                  
                                                                                                                                                  	// A list of email addresses of the users. Documents owned by these users are
                                                                                                                                                  	// excluded from the index. Documents shared with excluded users are indexed unless
                                                                                                                                                  	// they are excluded in another way.
                                                                                                                                                  	ExcludeUserAccounts []string
                                                                                                                                                  
                                                                                                                                                  	// A list of regular expression patterns that apply to the path on Google Drive.
                                                                                                                                                  	// Items that match the pattern are excluded from the index from both shared drives
                                                                                                                                                  	// and users' My Drives. Items that don't match the pattern are included in the
                                                                                                                                                  	// index. If an item matches both an exclusion pattern and an inclusion pattern, it
                                                                                                                                                  	// is excluded from the index.
                                                                                                                                                  	ExclusionPatterns []string
                                                                                                                                                  
                                                                                                                                                  	// Defines mapping between a field in the Google Drive and a Amazon Kendra index
                                                                                                                                                  	// field. If you are using the console, you can define index fields when creating
                                                                                                                                                  	// the mapping. If you are using the API, you must first create the field using the
                                                                                                                                                  	// UpdateIndex operation.
                                                                                                                                                  	FieldMappings []DataSourceToIndexFieldMapping
                                                                                                                                                  
                                                                                                                                                  	// A list of regular expression patterns that apply to path on Google Drive. Items
                                                                                                                                                  	// that match the pattern are included in the index from both shared drives and
                                                                                                                                                  	// users' My Drives. Items that don't match the pattern are excluded from the
                                                                                                                                                  	// index. If an item matches both an inclusion pattern and an exclusion pattern, it
                                                                                                                                                  	// is excluded from the index.
                                                                                                                                                  	InclusionPatterns []string
                                                                                                                                                  }

                                                                                                                                                    Provides configuration information for data sources that connect to Google Drive.

                                                                                                                                                    type Highlight

                                                                                                                                                    type Highlight struct {
                                                                                                                                                    
                                                                                                                                                    	// The zero-based location in the response string where the highlight starts.
                                                                                                                                                    	//
                                                                                                                                                    	// This member is required.
                                                                                                                                                    	BeginOffset *int32
                                                                                                                                                    
                                                                                                                                                    	// The zero-based location in the response string where the highlight ends.
                                                                                                                                                    	//
                                                                                                                                                    	// This member is required.
                                                                                                                                                    	EndOffset *int32
                                                                                                                                                    
                                                                                                                                                    	// Indicates whether the response is the best response. True if this is the best
                                                                                                                                                    	// response; otherwise, false.
                                                                                                                                                    	TopAnswer bool
                                                                                                                                                    
                                                                                                                                                    	// The highlight type.
                                                                                                                                                    	Type HighlightType
                                                                                                                                                    }

                                                                                                                                                      Provides information that you can use to highlight a search result so that your users can quickly identify terms in the response.

                                                                                                                                                      type HighlightType

                                                                                                                                                      type HighlightType string
                                                                                                                                                      const (
                                                                                                                                                      	HighlightTypeStandard         HighlightType = "STANDARD"
                                                                                                                                                      	HighlightTypeThesaurusSynonym HighlightType = "THESAURUS_SYNONYM"
                                                                                                                                                      )

                                                                                                                                                        Enum values for HighlightType

                                                                                                                                                        func (HighlightType) Values

                                                                                                                                                        func (HighlightType) Values() []HighlightType

                                                                                                                                                          Values returns all known values for HighlightType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                          type IndexConfigurationSummary

                                                                                                                                                          type IndexConfigurationSummary struct {
                                                                                                                                                          
                                                                                                                                                          	// The Unix timestamp when the index was created.
                                                                                                                                                          	//
                                                                                                                                                          	// This member is required.
                                                                                                                                                          	CreatedAt *time.Time
                                                                                                                                                          
                                                                                                                                                          	// The current status of the index. When the status is ACTIVE, the index is ready
                                                                                                                                                          	// to search.
                                                                                                                                                          	//
                                                                                                                                                          	// This member is required.
                                                                                                                                                          	Status IndexStatus
                                                                                                                                                          
                                                                                                                                                          	// The Unix timestamp when the index was last updated by the UpdateIndex operation.
                                                                                                                                                          	//
                                                                                                                                                          	// This member is required.
                                                                                                                                                          	UpdatedAt *time.Time
                                                                                                                                                          
                                                                                                                                                          	// Indicates whether the index is a enterprise edition index or a developer edition
                                                                                                                                                          	// index.
                                                                                                                                                          	Edition IndexEdition
                                                                                                                                                          
                                                                                                                                                          	// A unique identifier for the index. Use this to identify the index when you are
                                                                                                                                                          	// using operations such as Query, DescribeIndex, UpdateIndex, and DeleteIndex.
                                                                                                                                                          	Id *string
                                                                                                                                                          
                                                                                                                                                          	// The name of the index.
                                                                                                                                                          	Name *string
                                                                                                                                                          }

                                                                                                                                                            A summary of information about an index.

                                                                                                                                                            type IndexEdition

                                                                                                                                                            type IndexEdition string
                                                                                                                                                            const (
                                                                                                                                                            	IndexEditionDeveloperEdition  IndexEdition = "DEVELOPER_EDITION"
                                                                                                                                                            	IndexEditionEnterpriseEdition IndexEdition = "ENTERPRISE_EDITION"
                                                                                                                                                            )

                                                                                                                                                              Enum values for IndexEdition

                                                                                                                                                              func (IndexEdition) Values

                                                                                                                                                              func (IndexEdition) Values() []IndexEdition

                                                                                                                                                                Values returns all known values for IndexEdition. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                type IndexStatistics

                                                                                                                                                                type IndexStatistics struct {
                                                                                                                                                                
                                                                                                                                                                	// The number of question and answer topics in the index.
                                                                                                                                                                	//
                                                                                                                                                                	// This member is required.
                                                                                                                                                                	FaqStatistics *FaqStatistics
                                                                                                                                                                
                                                                                                                                                                	// The number of text documents indexed.
                                                                                                                                                                	//
                                                                                                                                                                	// This member is required.
                                                                                                                                                                	TextDocumentStatistics *TextDocumentStatistics
                                                                                                                                                                }

                                                                                                                                                                  Provides information about the number of documents and the number of questions and answers in an index.

                                                                                                                                                                  type IndexStatus

                                                                                                                                                                  type IndexStatus string
                                                                                                                                                                  const (
                                                                                                                                                                  	IndexStatusCreating       IndexStatus = "CREATING"
                                                                                                                                                                  	IndexStatusActive         IndexStatus = "ACTIVE"
                                                                                                                                                                  	IndexStatusDeleting       IndexStatus = "DELETING"
                                                                                                                                                                  	IndexStatusFailed         IndexStatus = "FAILED"
                                                                                                                                                                  	IndexStatusUpdating       IndexStatus = "UPDATING"
                                                                                                                                                                  	IndexStatusSystemUpdating IndexStatus = "SYSTEM_UPDATING"
                                                                                                                                                                  )

                                                                                                                                                                    Enum values for IndexStatus

                                                                                                                                                                    func (IndexStatus) Values

                                                                                                                                                                    func (IndexStatus) Values() []IndexStatus

                                                                                                                                                                      Values returns all known values for IndexStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                      type InternalServerException

                                                                                                                                                                      type InternalServerException struct {
                                                                                                                                                                      	Message *string
                                                                                                                                                                      }

                                                                                                                                                                      func (*InternalServerException) Error

                                                                                                                                                                      func (e *InternalServerException) Error() string

                                                                                                                                                                      func (*InternalServerException) ErrorCode

                                                                                                                                                                      func (e *InternalServerException) ErrorCode() string

                                                                                                                                                                      func (*InternalServerException) ErrorFault

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

                                                                                                                                                                      func (*InternalServerException) ErrorMessage

                                                                                                                                                                      func (e *InternalServerException) ErrorMessage() string

                                                                                                                                                                      type JsonTokenTypeConfiguration

                                                                                                                                                                      type JsonTokenTypeConfiguration struct {
                                                                                                                                                                      
                                                                                                                                                                      	// The group attribute field.
                                                                                                                                                                      	//
                                                                                                                                                                      	// This member is required.
                                                                                                                                                                      	GroupAttributeField *string
                                                                                                                                                                      
                                                                                                                                                                      	// The user name attribute field.
                                                                                                                                                                      	//
                                                                                                                                                                      	// This member is required.
                                                                                                                                                                      	UserNameAttributeField *string
                                                                                                                                                                      }

                                                                                                                                                                        Configuration information for the JSON token type.

                                                                                                                                                                        type JwtTokenTypeConfiguration

                                                                                                                                                                        type JwtTokenTypeConfiguration struct {
                                                                                                                                                                        
                                                                                                                                                                        	// The location of the key.
                                                                                                                                                                        	//
                                                                                                                                                                        	// This member is required.
                                                                                                                                                                        	KeyLocation KeyLocation
                                                                                                                                                                        
                                                                                                                                                                        	// The regular expression that identifies the claim.
                                                                                                                                                                        	ClaimRegex *string
                                                                                                                                                                        
                                                                                                                                                                        	// The group attribute field.
                                                                                                                                                                        	GroupAttributeField *string
                                                                                                                                                                        
                                                                                                                                                                        	// The issuer of the token.
                                                                                                                                                                        	Issuer *string
                                                                                                                                                                        
                                                                                                                                                                        	// The Amazon Resource Name (arn) of the secret.
                                                                                                                                                                        	SecretManagerArn *string
                                                                                                                                                                        
                                                                                                                                                                        	// The signing key URL.
                                                                                                                                                                        	URL *string
                                                                                                                                                                        
                                                                                                                                                                        	// The user name attribute field.
                                                                                                                                                                        	UserNameAttributeField *string
                                                                                                                                                                        }

                                                                                                                                                                          Configuration information for the JWT token type.

                                                                                                                                                                          type KeyLocation

                                                                                                                                                                          type KeyLocation string
                                                                                                                                                                          const (
                                                                                                                                                                          	KeyLocationUrl           KeyLocation = "URL"
                                                                                                                                                                          	KeyLocationSecretManager KeyLocation = "SECRET_MANAGER"
                                                                                                                                                                          )

                                                                                                                                                                            Enum values for KeyLocation

                                                                                                                                                                            func (KeyLocation) Values

                                                                                                                                                                            func (KeyLocation) Values() []KeyLocation

                                                                                                                                                                              Values returns all known values for KeyLocation. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                              type OneDriveConfiguration

                                                                                                                                                                              type OneDriveConfiguration struct {
                                                                                                                                                                              
                                                                                                                                                                              	// A list of user accounts whose documents should be indexed.
                                                                                                                                                                              	//
                                                                                                                                                                              	// This member is required.
                                                                                                                                                                              	OneDriveUsers *OneDriveUsers
                                                                                                                                                                              
                                                                                                                                                                              	// The Amazon Resource Name (ARN) of an AWS Secrets Manager secret that contains
                                                                                                                                                                              	// the user name and password to connect to OneDrive. The user namd should be the
                                                                                                                                                                              	// application ID for the OneDrive application, and the password is the application
                                                                                                                                                                              	// key for the OneDrive application.
                                                                                                                                                                              	//
                                                                                                                                                                              	// This member is required.
                                                                                                                                                                              	SecretArn *string
                                                                                                                                                                              
                                                                                                                                                                              	// The Azure Active Directory domain of the organization.
                                                                                                                                                                              	//
                                                                                                                                                                              	// This member is required.
                                                                                                                                                                              	TenantDomain *string
                                                                                                                                                                              
                                                                                                                                                                              	// A Boolean value that specifies whether local groups are disabled (True) or
                                                                                                                                                                              	// enabled (False).
                                                                                                                                                                              	DisableLocalGroups bool
                                                                                                                                                                              
                                                                                                                                                                              	// List of regular expressions applied to documents. Items that match the exclusion
                                                                                                                                                                              	// pattern are not indexed. If you provide both an inclusion pattern and an
                                                                                                                                                                              	// exclusion pattern, any item that matches the exclusion pattern isn't indexed.
                                                                                                                                                                              	// The exclusion pattern is applied to the file name.
                                                                                                                                                                              	ExclusionPatterns []string
                                                                                                                                                                              
                                                                                                                                                                              	// A list of DataSourceToIndexFieldMapping objects that map Microsoft OneDrive
                                                                                                                                                                              	// fields to custom fields in the Amazon Kendra index. You must first create the
                                                                                                                                                                              	// index fields before you map OneDrive fields.
                                                                                                                                                                              	FieldMappings []DataSourceToIndexFieldMapping
                                                                                                                                                                              
                                                                                                                                                                              	// A list of regular expression patterns. Documents that match the pattern are
                                                                                                                                                                              	// included in the index. Documents that don't match the pattern are excluded from
                                                                                                                                                                              	// the index. If a document matches both an inclusion pattern and an exclusion
                                                                                                                                                                              	// pattern, the document is not included in the index. The exclusion pattern is
                                                                                                                                                                              	// applied to the file name.
                                                                                                                                                                              	InclusionPatterns []string
                                                                                                                                                                              }

                                                                                                                                                                                Provides configuration information for data sources that connect to OneDrive.

                                                                                                                                                                                type OneDriveUsers

                                                                                                                                                                                type OneDriveUsers struct {
                                                                                                                                                                                
                                                                                                                                                                                	// A list of users whose documents should be indexed. Specify the user names in
                                                                                                                                                                                	// email format, for example, username@tenantdomain. If you need to index the
                                                                                                                                                                                	// documents of more than 100 users, use the OneDriveUserS3Path field to specify
                                                                                                                                                                                	// the location of a file containing a list of users.
                                                                                                                                                                                	OneDriveUserList []string
                                                                                                                                                                                
                                                                                                                                                                                	// The S3 bucket location of a file containing a list of users whose documents
                                                                                                                                                                                	// should be indexed.
                                                                                                                                                                                	OneDriveUserS3Path *S3Path
                                                                                                                                                                                }

                                                                                                                                                                                  User accounts whose documents should be indexed.

                                                                                                                                                                                  type Order

                                                                                                                                                                                  type Order string
                                                                                                                                                                                  const (
                                                                                                                                                                                  	OrderAscending  Order = "ASCENDING"
                                                                                                                                                                                  	OrderDescending Order = "DESCENDING"
                                                                                                                                                                                  )

                                                                                                                                                                                    Enum values for Order

                                                                                                                                                                                    func (Order) Values

                                                                                                                                                                                    func (Order) Values() []Order

                                                                                                                                                                                      Values returns all known values for Order. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                      type Principal

                                                                                                                                                                                      type Principal struct {
                                                                                                                                                                                      
                                                                                                                                                                                      	// Whether to allow or deny access to the principal.
                                                                                                                                                                                      	//
                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                      	Access ReadAccessType
                                                                                                                                                                                      
                                                                                                                                                                                      	// The name of the user or group.
                                                                                                                                                                                      	//
                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                      	Name *string
                                                                                                                                                                                      
                                                                                                                                                                                      	// The type of principal.
                                                                                                                                                                                      	//
                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                      	Type PrincipalType
                                                                                                                                                                                      }

                                                                                                                                                                                        Provides user and group information for document access filtering.

                                                                                                                                                                                        type PrincipalType

                                                                                                                                                                                        type PrincipalType string
                                                                                                                                                                                        const (
                                                                                                                                                                                        	PrincipalTypeUser  PrincipalType = "USER"
                                                                                                                                                                                        	PrincipalTypeGroup PrincipalType = "GROUP"
                                                                                                                                                                                        )

                                                                                                                                                                                          Enum values for PrincipalType

                                                                                                                                                                                          func (PrincipalType) Values

                                                                                                                                                                                          func (PrincipalType) Values() []PrincipalType

                                                                                                                                                                                            Values returns all known values for PrincipalType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                            type QueryIdentifiersEnclosingOption

                                                                                                                                                                                            type QueryIdentifiersEnclosingOption string
                                                                                                                                                                                            const (
                                                                                                                                                                                            	QueryIdentifiersEnclosingOptionDoubleQuotes QueryIdentifiersEnclosingOption = "DOUBLE_QUOTES"
                                                                                                                                                                                            	QueryIdentifiersEnclosingOptionNone         QueryIdentifiersEnclosingOption = "NONE"
                                                                                                                                                                                            )

                                                                                                                                                                                              Enum values for QueryIdentifiersEnclosingOption

                                                                                                                                                                                              func (QueryIdentifiersEnclosingOption) Values

                                                                                                                                                                                                Values returns all known values for QueryIdentifiersEnclosingOption. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                type QueryResultItem

                                                                                                                                                                                                type QueryResultItem struct {
                                                                                                                                                                                                
                                                                                                                                                                                                	// One or more additional attributes associated with the query result.
                                                                                                                                                                                                	AdditionalAttributes []AdditionalResultAttribute
                                                                                                                                                                                                
                                                                                                                                                                                                	// An array of document attributes for the document that the query result maps to.
                                                                                                                                                                                                	// For example, the document author (Author) or the source URI (SourceUri) of the
                                                                                                                                                                                                	// document.
                                                                                                                                                                                                	DocumentAttributes []DocumentAttribute
                                                                                                                                                                                                
                                                                                                                                                                                                	// An extract of the text in the document. Contains information about highlighting
                                                                                                                                                                                                	// the relevant terms in the excerpt.
                                                                                                                                                                                                	DocumentExcerpt *TextWithHighlights
                                                                                                                                                                                                
                                                                                                                                                                                                	// The unique identifier for the document.
                                                                                                                                                                                                	DocumentId *string
                                                                                                                                                                                                
                                                                                                                                                                                                	// The title of the document. Contains the text of the title and information for
                                                                                                                                                                                                	// highlighting the relevant terms in the title.
                                                                                                                                                                                                	DocumentTitle *TextWithHighlights
                                                                                                                                                                                                
                                                                                                                                                                                                	// The URI of the original location of the document.
                                                                                                                                                                                                	DocumentURI *string
                                                                                                                                                                                                
                                                                                                                                                                                                	// A token that identifies a particular result from a particular query. Use this
                                                                                                                                                                                                	// token to provide click-through feedback for the result. For more information,
                                                                                                                                                                                                	// see  Submitting feedback
                                                                                                                                                                                                	// (https://docs.aws.amazon.com/kendra/latest/dg/submitting-feedback.html).
                                                                                                                                                                                                	FeedbackToken *string
                                                                                                                                                                                                
                                                                                                                                                                                                	// The unique identifier for the query result.
                                                                                                                                                                                                	Id *string
                                                                                                                                                                                                
                                                                                                                                                                                                	// Indicates the confidence that Amazon Kendra has that a result matches the query
                                                                                                                                                                                                	// that you provided. Each result is placed into a bin that indicates the
                                                                                                                                                                                                	// confidence, VERY_HIGH, HIGH, MEDIUM and LOW. You can use the score to determine
                                                                                                                                                                                                	// if a response meets the confidence needed for your application. The field is
                                                                                                                                                                                                	// only set to LOW when the Type field is set to DOCUMENT and Amazon Kendra is not
                                                                                                                                                                                                	// confident that the result matches the query.
                                                                                                                                                                                                	ScoreAttributes *ScoreAttributes
                                                                                                                                                                                                
                                                                                                                                                                                                	// The type of document.
                                                                                                                                                                                                	Type QueryResultType
                                                                                                                                                                                                }

                                                                                                                                                                                                  A single query result. A query result contains information about a document returned by the query. This includes the original location of the document, a list of attributes assigned to the document, and relevant text from the document that satisfies the query.

                                                                                                                                                                                                  type QueryResultType

                                                                                                                                                                                                  type QueryResultType string
                                                                                                                                                                                                  const (
                                                                                                                                                                                                  	QueryResultTypeDocument       QueryResultType = "DOCUMENT"
                                                                                                                                                                                                  	QueryResultTypeQuestionAnswer QueryResultType = "QUESTION_ANSWER"
                                                                                                                                                                                                  	QueryResultTypeAnswer         QueryResultType = "ANSWER"
                                                                                                                                                                                                  )

                                                                                                                                                                                                    Enum values for QueryResultType

                                                                                                                                                                                                    func (QueryResultType) Values

                                                                                                                                                                                                    func (QueryResultType) Values() []QueryResultType

                                                                                                                                                                                                      Values returns all known values for QueryResultType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                      type ReadAccessType

                                                                                                                                                                                                      type ReadAccessType string
                                                                                                                                                                                                      const (
                                                                                                                                                                                                      	ReadAccessTypeAllow ReadAccessType = "ALLOW"
                                                                                                                                                                                                      	ReadAccessTypeDeny  ReadAccessType = "DENY"
                                                                                                                                                                                                      )

                                                                                                                                                                                                        Enum values for ReadAccessType

                                                                                                                                                                                                        func (ReadAccessType) Values

                                                                                                                                                                                                        func (ReadAccessType) Values() []ReadAccessType

                                                                                                                                                                                                          Values returns all known values for ReadAccessType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                          type Relevance

                                                                                                                                                                                                          type Relevance struct {
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// Specifies the time period that the boost applies to. For example, to make the
                                                                                                                                                                                                          	// boost apply to documents with the field value within the last month, you would
                                                                                                                                                                                                          	// use "2628000s". Once the field value is beyond the specified range, the effect
                                                                                                                                                                                                          	// of the boost drops off. The higher the importance, the faster the effect drops
                                                                                                                                                                                                          	// off. If you don't specify a value, the default is 3 months. The value of the
                                                                                                                                                                                                          	// field is a numeric string followed by the character "s", for example "86400s"
                                                                                                                                                                                                          	// for one day, or "604800s" for one week. Only applies to DATE fields.
                                                                                                                                                                                                          	Duration *string
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// Indicates that this field determines how "fresh" a document is. For example, if
                                                                                                                                                                                                          	// document 1 was created on November 5, and document 2 was created on October 31,
                                                                                                                                                                                                          	// document 1 is "fresher" than document 2. You can only set the Freshness field on
                                                                                                                                                                                                          	// one DATE type field. Only applies to DATE fields.
                                                                                                                                                                                                          	Freshness *bool
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// The relative importance of the field in the search. Larger numbers provide more
                                                                                                                                                                                                          	// of a boost than smaller numbers.
                                                                                                                                                                                                          	Importance *int32
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// Determines how values should be interpreted. When the RankOrder field is
                                                                                                                                                                                                          	// ASCENDING, higher numbers are better. For example, a document with a rating
                                                                                                                                                                                                          	// score of 10 is higher ranking than a document with a rating score of 1. When the
                                                                                                                                                                                                          	// RankOrder field is DESCENDING, lower numbers are better. For example, in a task
                                                                                                                                                                                                          	// tracking application, a priority 1 task is more important than a priority 5
                                                                                                                                                                                                          	// task. Only applies to LONG and DOUBLE fields.
                                                                                                                                                                                                          	RankOrder Order
                                                                                                                                                                                                          
                                                                                                                                                                                                          	// A list of values that should be given a different boost when they appear in the
                                                                                                                                                                                                          	// result list. For example, if you are boosting a field called "department," query
                                                                                                                                                                                                          	// terms that match the department field are boosted in the result. However, you
                                                                                                                                                                                                          	// can add entries from the department field to boost documents with those values
                                                                                                                                                                                                          	// higher. For example, you can add entries to the map with names of departments.
                                                                                                                                                                                                          	// If you add "HR",5 and "Legal",3 those departments are given special attention
                                                                                                                                                                                                          	// when they appear in the metadata of a document. When those terms appear they are
                                                                                                                                                                                                          	// given the specified importance instead of the regular importance for the boost.
                                                                                                                                                                                                          	ValueImportanceMap map[string]int32
                                                                                                                                                                                                          }

                                                                                                                                                                                                            Provides information for manually tuning the relevance of a field in a search. When a query includes terms that match the field, the results are given a boost in the response based on these tuning parameters.

                                                                                                                                                                                                            type RelevanceFeedback

                                                                                                                                                                                                            type RelevanceFeedback struct {
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// Whether to document was relevant or not relevant to the search.
                                                                                                                                                                                                            	//
                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                            	RelevanceValue RelevanceType
                                                                                                                                                                                                            
                                                                                                                                                                                                            	// The unique identifier of the search result that the user provided relevance
                                                                                                                                                                                                            	// feedback for.
                                                                                                                                                                                                            	//
                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                            	ResultId *string
                                                                                                                                                                                                            }

                                                                                                                                                                                                              Provides feedback on how relevant a document is to a search. Your application uses the SubmitFeedback operation to provide relevance information.

                                                                                                                                                                                                              type RelevanceType

                                                                                                                                                                                                              type RelevanceType string
                                                                                                                                                                                                              const (
                                                                                                                                                                                                              	RelevanceTypeRelevant    RelevanceType = "RELEVANT"
                                                                                                                                                                                                              	RelevanceTypeNotRelevant RelevanceType = "NOT_RELEVANT"
                                                                                                                                                                                                              )

                                                                                                                                                                                                                Enum values for RelevanceType

                                                                                                                                                                                                                func (RelevanceType) Values

                                                                                                                                                                                                                func (RelevanceType) Values() []RelevanceType

                                                                                                                                                                                                                  Values returns all known values for RelevanceType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                  type ResourceAlreadyExistException

                                                                                                                                                                                                                  type ResourceAlreadyExistException struct {
                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                  }

                                                                                                                                                                                                                  func (*ResourceAlreadyExistException) Error

                                                                                                                                                                                                                  func (*ResourceAlreadyExistException) ErrorCode

                                                                                                                                                                                                                  func (e *ResourceAlreadyExistException) ErrorCode() string

                                                                                                                                                                                                                  func (*ResourceAlreadyExistException) ErrorFault

                                                                                                                                                                                                                  func (*ResourceAlreadyExistException) ErrorMessage

                                                                                                                                                                                                                  func (e *ResourceAlreadyExistException) ErrorMessage() string

                                                                                                                                                                                                                  type ResourceInUseException

                                                                                                                                                                                                                  type ResourceInUseException struct {
                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                  }

                                                                                                                                                                                                                  func (*ResourceInUseException) Error

                                                                                                                                                                                                                  func (e *ResourceInUseException) Error() string

                                                                                                                                                                                                                  func (*ResourceInUseException) ErrorCode

                                                                                                                                                                                                                  func (e *ResourceInUseException) ErrorCode() string

                                                                                                                                                                                                                  func (*ResourceInUseException) ErrorFault

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

                                                                                                                                                                                                                  func (*ResourceInUseException) ErrorMessage

                                                                                                                                                                                                                  func (e *ResourceInUseException) ErrorMessage() string

                                                                                                                                                                                                                  type ResourceNotFoundException

                                                                                                                                                                                                                  type ResourceNotFoundException struct {
                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                  }

                                                                                                                                                                                                                  func (*ResourceNotFoundException) Error

                                                                                                                                                                                                                  func (e *ResourceNotFoundException) Error() string

                                                                                                                                                                                                                  func (*ResourceNotFoundException) ErrorCode

                                                                                                                                                                                                                  func (e *ResourceNotFoundException) ErrorCode() string

                                                                                                                                                                                                                  func (*ResourceNotFoundException) ErrorFault

                                                                                                                                                                                                                  func (*ResourceNotFoundException) ErrorMessage

                                                                                                                                                                                                                  func (e *ResourceNotFoundException) ErrorMessage() string

                                                                                                                                                                                                                  type ResourceUnavailableException

                                                                                                                                                                                                                  type ResourceUnavailableException struct {
                                                                                                                                                                                                                  	Message *string
                                                                                                                                                                                                                  }

                                                                                                                                                                                                                  func (*ResourceUnavailableException) Error

                                                                                                                                                                                                                  func (*ResourceUnavailableException) ErrorCode

                                                                                                                                                                                                                  func (e *ResourceUnavailableException) ErrorCode() string

                                                                                                                                                                                                                  func (*ResourceUnavailableException) ErrorFault

                                                                                                                                                                                                                  func (*ResourceUnavailableException) ErrorMessage

                                                                                                                                                                                                                  func (e *ResourceUnavailableException) ErrorMessage() string

                                                                                                                                                                                                                  type S3DataSourceConfiguration

                                                                                                                                                                                                                  type S3DataSourceConfiguration struct {
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// The name of the bucket that contains the documents.
                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                  	BucketName *string
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// Provides the path to the S3 bucket that contains the user context filtering
                                                                                                                                                                                                                  	// files for the data source. For the format of the file, see Access control for S3
                                                                                                                                                                                                                  	// data sources (https://docs.aws.amazon.com/kendra/latest/dg/s3-acl.html).
                                                                                                                                                                                                                  	AccessControlListConfiguration *AccessControlListConfiguration
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// Document metadata files that contain information such as the document access
                                                                                                                                                                                                                  	// control information, source URI, document author, and custom attributes. Each
                                                                                                                                                                                                                  	// metadata file contains metadata about a single document.
                                                                                                                                                                                                                  	DocumentsMetadataConfiguration *DocumentsMetadataConfiguration
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// A list of glob patterns for documents that should not be indexed. If a document
                                                                                                                                                                                                                  	// that matches an inclusion prefix or inclusion pattern also matches an exclusion
                                                                                                                                                                                                                  	// pattern, the document is not indexed. For more information about glob patterns,
                                                                                                                                                                                                                  	// see glob (programming) (https://en.wikipedia.org/wiki/Glob_(programming)) in
                                                                                                                                                                                                                  	// Wikipedia.
                                                                                                                                                                                                                  	ExclusionPatterns []string
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// A list of glob patterns for documents that should be indexed. If a document that
                                                                                                                                                                                                                  	// matches an inclusion pattern also matches an exclusion pattern, the document is
                                                                                                                                                                                                                  	// not indexed. For more information about glob patterns, see glob (programming)
                                                                                                                                                                                                                  	// (https://en.wikipedia.org/wiki/Glob_(programming)) in Wikipedia.
                                                                                                                                                                                                                  	InclusionPatterns []string
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  	// A list of S3 prefixes for the documents that should be included in the index.
                                                                                                                                                                                                                  	InclusionPrefixes []string
                                                                                                                                                                                                                  }

                                                                                                                                                                                                                    Provides configuration information for a data source to index documents in an Amazon S3 bucket.

                                                                                                                                                                                                                    type S3Path

                                                                                                                                                                                                                    type S3Path struct {
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// The name of the S3 bucket that contains the file.
                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                    	Bucket *string
                                                                                                                                                                                                                    
                                                                                                                                                                                                                    	// The name of the file.
                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                    	Key *string
                                                                                                                                                                                                                    }

                                                                                                                                                                                                                      Information required to find a specific file in an Amazon S3 bucket.

                                                                                                                                                                                                                      type SalesforceChatterFeedConfiguration

                                                                                                                                                                                                                      type SalesforceChatterFeedConfiguration struct {
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The name of the column in the Salesforce FeedItem table that contains the
                                                                                                                                                                                                                      	// content to index. Typically this is the Body column.
                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                      	DocumentDataFieldName *string
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// The name of the column in the Salesforce FeedItem table that contains the title
                                                                                                                                                                                                                      	// of the document. This is typically the Title collumn.
                                                                                                                                                                                                                      	DocumentTitleFieldName *string
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// Maps fields from a Salesforce chatter feed into Amazon Kendra index fields.
                                                                                                                                                                                                                      	FieldMappings []DataSourceToIndexFieldMapping
                                                                                                                                                                                                                      
                                                                                                                                                                                                                      	// Filters the documents in the feed based on status of the user. When you specify
                                                                                                                                                                                                                      	// ACTIVE_USERS only documents from users who have an active account are indexed.
                                                                                                                                                                                                                      	// When you specify STANDARD_USER only documents for Salesforce standard users are
                                                                                                                                                                                                                      	// documented. You can specify both.
                                                                                                                                                                                                                      	IncludeFilterTypes []SalesforceChatterFeedIncludeFilterType
                                                                                                                                                                                                                      }

                                                                                                                                                                                                                        Defines configuration for syncing a Salesforce chatter feed. The contents of the object comes from the Salesforce FeedItem table.

                                                                                                                                                                                                                        type SalesforceChatterFeedIncludeFilterType

                                                                                                                                                                                                                        type SalesforceChatterFeedIncludeFilterType string
                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                        	SalesforceChatterFeedIncludeFilterTypeActiveUser   SalesforceChatterFeedIncludeFilterType = "ACTIVE_USER"
                                                                                                                                                                                                                        	SalesforceChatterFeedIncludeFilterTypeStandardUser SalesforceChatterFeedIncludeFilterType = "STANDARD_USER"
                                                                                                                                                                                                                        )

                                                                                                                                                                                                                          Enum values for SalesforceChatterFeedIncludeFilterType

                                                                                                                                                                                                                          func (SalesforceChatterFeedIncludeFilterType) Values

                                                                                                                                                                                                                            Values returns all known values for SalesforceChatterFeedIncludeFilterType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                            type SalesforceConfiguration

                                                                                                                                                                                                                            type SalesforceConfiguration struct {
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// The Amazon Resource Name (ARN) of an AWS Secrets Manager secret that contains
                                                                                                                                                                                                                            	// the key/value pairs required to connect to your Salesforce instance. The secret
                                                                                                                                                                                                                            	// must contain a JSON structure with the following keys:
                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                            	// * authenticationUrl -
                                                                                                                                                                                                                            	// The OAUTH endpoint that Amazon Kendra connects to get an OAUTH token.
                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                            	// *
                                                                                                                                                                                                                            	// consumerKey - The application public key generated when you created your
                                                                                                                                                                                                                            	// Salesforce application.
                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                            	// * consumerSecret - The application private key
                                                                                                                                                                                                                            	// generated when you created your Salesforce application.
                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                            	// * password - The
                                                                                                                                                                                                                            	// password associated with the user logging in to the Salesforce instance.
                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                            	// *
                                                                                                                                                                                                                            	// securityToken - The token associated with the user account logging in to the
                                                                                                                                                                                                                            	// Salesforce instance.
                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                            	// * username - The user name of the user logging in to the
                                                                                                                                                                                                                            	// Salesforce instance.
                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                            	SecretArn *string
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// The instance URL for the Salesforce site that you want to index.
                                                                                                                                                                                                                            	//
                                                                                                                                                                                                                            	// This member is required.
                                                                                                                                                                                                                            	ServerUrl *string
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// Specifies configuration information for Salesforce chatter feeds.
                                                                                                                                                                                                                            	ChatterFeedConfiguration *SalesforceChatterFeedConfiguration
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// Indicates whether Amazon Kendra should index attachments to Salesforce objects.
                                                                                                                                                                                                                            	CrawlAttachments bool
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// A list of regular expression patterns. Documents that match the patterns are
                                                                                                                                                                                                                            	// excluded from the index. Documents that don't match the patterns are included in
                                                                                                                                                                                                                            	// the index. If a document matches both an exclusion pattern and an inclusion
                                                                                                                                                                                                                            	// pattern, the document is not included in the index. The regex is applied to the
                                                                                                                                                                                                                            	// name of the attached file.
                                                                                                                                                                                                                            	ExcludeAttachmentFilePatterns []string
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// A list of regular expression patterns. Documents that match the patterns are
                                                                                                                                                                                                                            	// included in the index. Documents that don't match the patterns are excluded from
                                                                                                                                                                                                                            	// the index. If a document matches both an inclusion pattern and an exclusion
                                                                                                                                                                                                                            	// pattern, the document is not included in the index. The regex is applied to the
                                                                                                                                                                                                                            	// name of the attached file.
                                                                                                                                                                                                                            	IncludeAttachmentFilePatterns []string
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// Specifies configuration information for the knowlege article types that Amazon
                                                                                                                                                                                                                            	// Kendra indexes. Amazon Kendra indexes standard knowledge articles and the
                                                                                                                                                                                                                            	// standard fields of knowledge articles, or the custom fields of custom knowledge
                                                                                                                                                                                                                            	// articles, but not both.
                                                                                                                                                                                                                            	KnowledgeArticleConfiguration *SalesforceKnowledgeArticleConfiguration
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// Provides configuration information for processing attachments to Salesforce
                                                                                                                                                                                                                            	// standard objects.
                                                                                                                                                                                                                            	StandardObjectAttachmentConfiguration *SalesforceStandardObjectAttachmentConfiguration
                                                                                                                                                                                                                            
                                                                                                                                                                                                                            	// Specifies the Salesforce standard objects that Amazon Kendra indexes.
                                                                                                                                                                                                                            	StandardObjectConfigurations []SalesforceStandardObjectConfiguration
                                                                                                                                                                                                                            }

                                                                                                                                                                                                                              Provides configuration information for connecting to a Salesforce data source.

                                                                                                                                                                                                                              type SalesforceCustomKnowledgeArticleTypeConfiguration

                                                                                                                                                                                                                              type SalesforceCustomKnowledgeArticleTypeConfiguration struct {
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The name of the field in the custom knowledge article that contains the document
                                                                                                                                                                                                                              	// data to index.
                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                              	DocumentDataFieldName *string
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The name of the configuration.
                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                              	Name *string
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// The name of the field in the custom knowledge article that contains the document
                                                                                                                                                                                                                              	// title.
                                                                                                                                                                                                                              	DocumentTitleFieldName *string
                                                                                                                                                                                                                              
                                                                                                                                                                                                                              	// One or more objects that map fields in the custom knowledge article to fields in
                                                                                                                                                                                                                              	// the Amazon Kendra index.
                                                                                                                                                                                                                              	FieldMappings []DataSourceToIndexFieldMapping
                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                Provides configuration information for indexing Salesforce custom articles.

                                                                                                                                                                                                                                type SalesforceKnowledgeArticleConfiguration

                                                                                                                                                                                                                                type SalesforceKnowledgeArticleConfiguration struct {
                                                                                                                                                                                                                                
                                                                                                                                                                                                                                	// Specifies the document states that should be included when Amazon Kendra indexes
                                                                                                                                                                                                                                	// knowledge articles. You must specify at least one state.
                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                	IncludedStates []SalesforceKnowledgeArticleState
                                                                                                                                                                                                                                
                                                                                                                                                                                                                                	// Provides configuration information for custom Salesforce knowledge articles.
                                                                                                                                                                                                                                	CustomKnowledgeArticleTypeConfigurations []SalesforceCustomKnowledgeArticleTypeConfiguration
                                                                                                                                                                                                                                
                                                                                                                                                                                                                                	// Provides configuration information for standard Salesforce knowledge articles.
                                                                                                                                                                                                                                	StandardKnowledgeArticleTypeConfiguration *SalesforceStandardKnowledgeArticleTypeConfiguration
                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                  Specifies configuration information for the knowlege article types that Amazon Kendra indexes. Amazon Kendra indexes standard knowledge articles and the standard fields of knowledge articles, or the custom fields of custom knowledge articles, but not both

                                                                                                                                                                                                                                  type SalesforceKnowledgeArticleState

                                                                                                                                                                                                                                  type SalesforceKnowledgeArticleState string
                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                  	SalesforceKnowledgeArticleStateDraft     SalesforceKnowledgeArticleState = "DRAFT"
                                                                                                                                                                                                                                  	SalesforceKnowledgeArticleStatePublished SalesforceKnowledgeArticleState = "PUBLISHED"
                                                                                                                                                                                                                                  	SalesforceKnowledgeArticleStateArchived  SalesforceKnowledgeArticleState = "ARCHIVED"
                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                    Enum values for SalesforceKnowledgeArticleState

                                                                                                                                                                                                                                    func (SalesforceKnowledgeArticleState) Values

                                                                                                                                                                                                                                      Values returns all known values for SalesforceKnowledgeArticleState. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                      type SalesforceStandardKnowledgeArticleTypeConfiguration

                                                                                                                                                                                                                                      type SalesforceStandardKnowledgeArticleTypeConfiguration struct {
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The name of the field that contains the document data to index.
                                                                                                                                                                                                                                      	//
                                                                                                                                                                                                                                      	// This member is required.
                                                                                                                                                                                                                                      	DocumentDataFieldName *string
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// The name of the field that contains the document title.
                                                                                                                                                                                                                                      	DocumentTitleFieldName *string
                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                      	// One or more objects that map fields in the knowledge article to Amazon Kendra
                                                                                                                                                                                                                                      	// index fields. The index field must exist before you can map a Salesforce field
                                                                                                                                                                                                                                      	// to it.
                                                                                                                                                                                                                                      	FieldMappings []DataSourceToIndexFieldMapping
                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                        Provides configuration information for standard Salesforce knowledge articles.

                                                                                                                                                                                                                                        type SalesforceStandardObjectAttachmentConfiguration

                                                                                                                                                                                                                                        type SalesforceStandardObjectAttachmentConfiguration struct {
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// The name of the field used for the document title.
                                                                                                                                                                                                                                        	DocumentTitleFieldName *string
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                        	// One or more objects that map fields in attachments to Amazon Kendra index
                                                                                                                                                                                                                                        	// fields.
                                                                                                                                                                                                                                        	FieldMappings []DataSourceToIndexFieldMapping
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                          Provides configuration information for processing attachments to Salesforce standard objects.

                                                                                                                                                                                                                                          type SalesforceStandardObjectConfiguration

                                                                                                                                                                                                                                          type SalesforceStandardObjectConfiguration struct {
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// The name of the field in the standard object table that contains the document
                                                                                                                                                                                                                                          	// contents.
                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                          	DocumentDataFieldName *string
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// The name of the standard object.
                                                                                                                                                                                                                                          	//
                                                                                                                                                                                                                                          	// This member is required.
                                                                                                                                                                                                                                          	Name SalesforceStandardObjectName
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// The name of the field in the standard object table that contains the document
                                                                                                                                                                                                                                          	// titleB.
                                                                                                                                                                                                                                          	DocumentTitleFieldName *string
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// One or more objects that map fields in the standard object to Amazon Kendra
                                                                                                                                                                                                                                          	// index fields. The index field must exist before you can map a Salesforce field
                                                                                                                                                                                                                                          	// to it.
                                                                                                                                                                                                                                          	FieldMappings []DataSourceToIndexFieldMapping
                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                            Specifies confguration information for indexing a single standard object.

                                                                                                                                                                                                                                            type SalesforceStandardObjectName

                                                                                                                                                                                                                                            type SalesforceStandardObjectName string
                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                            	SalesforceStandardObjectNameAccount     SalesforceStandardObjectName = "ACCOUNT"
                                                                                                                                                                                                                                            	SalesforceStandardObjectNameCampaign    SalesforceStandardObjectName = "CAMPAIGN"
                                                                                                                                                                                                                                            	SalesforceStandardObjectNameCase        SalesforceStandardObjectName = "CASE"
                                                                                                                                                                                                                                            	SalesforceStandardObjectNameContact     SalesforceStandardObjectName = "CONTACT"
                                                                                                                                                                                                                                            	SalesforceStandardObjectNameContract    SalesforceStandardObjectName = "CONTRACT"
                                                                                                                                                                                                                                            	SalesforceStandardObjectNameDocument    SalesforceStandardObjectName = "DOCUMENT"
                                                                                                                                                                                                                                            	SalesforceStandardObjectNameGroup       SalesforceStandardObjectName = "GROUP"
                                                                                                                                                                                                                                            	SalesforceStandardObjectNameIdea        SalesforceStandardObjectName = "IDEA"
                                                                                                                                                                                                                                            	SalesforceStandardObjectNameLead        SalesforceStandardObjectName = "LEAD"
                                                                                                                                                                                                                                            	SalesforceStandardObjectNameOpportunity SalesforceStandardObjectName = "OPPORTUNITY"
                                                                                                                                                                                                                                            	SalesforceStandardObjectNamePartner     SalesforceStandardObjectName = "PARTNER"
                                                                                                                                                                                                                                            	SalesforceStandardObjectNamePricebook   SalesforceStandardObjectName = "PRICEBOOK"
                                                                                                                                                                                                                                            	SalesforceStandardObjectNameProduct     SalesforceStandardObjectName = "PRODUCT"
                                                                                                                                                                                                                                            	SalesforceStandardObjectNameProfile     SalesforceStandardObjectName = "PROFILE"
                                                                                                                                                                                                                                            	SalesforceStandardObjectNameSolution    SalesforceStandardObjectName = "SOLUTION"
                                                                                                                                                                                                                                            	SalesforceStandardObjectNameTask        SalesforceStandardObjectName = "TASK"
                                                                                                                                                                                                                                            	SalesforceStandardObjectNameUser        SalesforceStandardObjectName = "USER"
                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                              Enum values for SalesforceStandardObjectName

                                                                                                                                                                                                                                              func (SalesforceStandardObjectName) Values

                                                                                                                                                                                                                                                Values returns all known values for SalesforceStandardObjectName. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                type ScoreAttributes

                                                                                                                                                                                                                                                type ScoreAttributes struct {
                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                	// A relative ranking for how well the response matches the query.
                                                                                                                                                                                                                                                	ScoreConfidence ScoreConfidence
                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                  Provides a relative ranking that indicates how confident Amazon Kendra is that the response matches the query.

                                                                                                                                                                                                                                                  type ScoreConfidence

                                                                                                                                                                                                                                                  type ScoreConfidence string
                                                                                                                                                                                                                                                  const (
                                                                                                                                                                                                                                                  	ScoreConfidenceVeryHigh ScoreConfidence = "VERY_HIGH"
                                                                                                                                                                                                                                                  	ScoreConfidenceHigh     ScoreConfidence = "HIGH"
                                                                                                                                                                                                                                                  	ScoreConfidenceMedium   ScoreConfidence = "MEDIUM"
                                                                                                                                                                                                                                                  	ScoreConfidenceLow      ScoreConfidence = "LOW"
                                                                                                                                                                                                                                                  )

                                                                                                                                                                                                                                                    Enum values for ScoreConfidence

                                                                                                                                                                                                                                                    func (ScoreConfidence) Values

                                                                                                                                                                                                                                                    func (ScoreConfidence) Values() []ScoreConfidence

                                                                                                                                                                                                                                                      Values returns all known values for ScoreConfidence. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                      type Search struct {
                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                      	// Determines whether the field is returned in the query response. The default is
                                                                                                                                                                                                                                                      	// true.
                                                                                                                                                                                                                                                      	Displayable bool
                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                      	// Indicates that the field can be used to create search facets, a count of results
                                                                                                                                                                                                                                                      	// for each value in the field. The default is false .
                                                                                                                                                                                                                                                      	Facetable bool
                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                      	// Determines whether the field is used in the search. If the Searchable field is
                                                                                                                                                                                                                                                      	// true, you can use relevance tuning to manually tune how Amazon Kendra weights
                                                                                                                                                                                                                                                      	// the field in the search. The default is true for string fields and false for
                                                                                                                                                                                                                                                      	// number and date fields.
                                                                                                                                                                                                                                                      	Searchable bool
                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                      	// Determines whether the field can be used to sort the results of a query. If you
                                                                                                                                                                                                                                                      	// specify sorting on a field that does not have Sortable set to true, Amazon
                                                                                                                                                                                                                                                      	// Kendra returns an exception. The default is false.
                                                                                                                                                                                                                                                      	Sortable bool
                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                        Provides information about how a custom index field is used during a search.

                                                                                                                                                                                                                                                        type ServerSideEncryptionConfiguration

                                                                                                                                                                                                                                                        type ServerSideEncryptionConfiguration struct {
                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                        	// The identifier of the AWS KMS customer master key (CMK). Amazon Kendra doesn't
                                                                                                                                                                                                                                                        	// support asymmetric CMKs.
                                                                                                                                                                                                                                                        	KmsKeyId *string
                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                          Provides the identifier of the AWS KMS customer master key (CMK) used to encrypt data indexed by Amazon Kendra. Amazon Kendra doesn't support asymmetric CMKs.

                                                                                                                                                                                                                                                          type ServiceNowBuildVersionType

                                                                                                                                                                                                                                                          type ServiceNowBuildVersionType string
                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                          	ServiceNowBuildVersionTypeLondon ServiceNowBuildVersionType = "LONDON"
                                                                                                                                                                                                                                                          	ServiceNowBuildVersionTypeOthers ServiceNowBuildVersionType = "OTHERS"
                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                            Enum values for ServiceNowBuildVersionType

                                                                                                                                                                                                                                                            func (ServiceNowBuildVersionType) Values

                                                                                                                                                                                                                                                              Values returns all known values for ServiceNowBuildVersionType. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                              type ServiceNowConfiguration

                                                                                                                                                                                                                                                              type ServiceNowConfiguration struct {
                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                              	// The ServiceNow instance that the data source connects to. The host endpoint
                                                                                                                                                                                                                                                              	// should look like the following: {instance}.service-now.com.
                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                              	HostUrl *string
                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                              	// The Amazon Resource Name (ARN) of the AWS Secret Manager secret that contains
                                                                                                                                                                                                                                                              	// the user name and password required to connect to the ServiceNow instance.
                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                              	SecretArn *string
                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                              	// The identifier of the release that the ServiceNow host is running. If the host
                                                                                                                                                                                                                                                              	// is not running the LONDON release, use OTHERS.
                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                              	ServiceNowBuildVersion ServiceNowBuildVersionType
                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                              	// Provides configuration information for crawling knowledge articles in the
                                                                                                                                                                                                                                                              	// ServiceNow site.
                                                                                                                                                                                                                                                              	KnowledgeArticleConfiguration *ServiceNowKnowledgeArticleConfiguration
                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                              	// Provides configuration information for crawling service catalogs in the
                                                                                                                                                                                                                                                              	// ServiceNow site.
                                                                                                                                                                                                                                                              	ServiceCatalogConfiguration *ServiceNowServiceCatalogConfiguration
                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                Provides configuration information required to connect to a ServiceNow data source.

                                                                                                                                                                                                                                                                type ServiceNowKnowledgeArticleConfiguration

                                                                                                                                                                                                                                                                type ServiceNowKnowledgeArticleConfiguration struct {
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The name of the ServiceNow field that is mapped to the index document contents
                                                                                                                                                                                                                                                                	// field in the Amazon Kendra index.
                                                                                                                                                                                                                                                                	//
                                                                                                                                                                                                                                                                	// This member is required.
                                                                                                                                                                                                                                                                	DocumentDataFieldName *string
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// Indicates whether Amazon Kendra should index attachments to knowledge articles.
                                                                                                                                                                                                                                                                	CrawlAttachments bool
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// The name of the ServiceNow field that is mapped to the index document title
                                                                                                                                                                                                                                                                	// field.
                                                                                                                                                                                                                                                                	DocumentTitleFieldName *string
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// List of regular expressions applied to knowledge articles. Items that don't
                                                                                                                                                                                                                                                                	// match the inclusion pattern are not indexed. The regex is applied to the field
                                                                                                                                                                                                                                                                	// specified in the PatternTargetField
                                                                                                                                                                                                                                                                	ExcludeAttachmentFilePatterns []string
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// Mapping between ServiceNow fields and Amazon Kendra index fields. You must
                                                                                                                                                                                                                                                                	// create the index field before you map the field.
                                                                                                                                                                                                                                                                	FieldMappings []DataSourceToIndexFieldMapping
                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                	// List of regular expressions applied to knowledge articles. Items that don't
                                                                                                                                                                                                                                                                	// match the inclusion pattern are not indexed. The regex is applied to the field
                                                                                                                                                                                                                                                                	// specified in the PatternTargetField.
                                                                                                                                                                                                                                                                	IncludeAttachmentFilePatterns []string
                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                  Provides configuration information for crawling knowledge articles in the ServiceNow site.

                                                                                                                                                                                                                                                                  type ServiceNowServiceCatalogConfiguration

                                                                                                                                                                                                                                                                  type ServiceNowServiceCatalogConfiguration struct {
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The name of the ServiceNow field that is mapped to the index document contents
                                                                                                                                                                                                                                                                  	// field in the Amazon Kendra index.
                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                  	DocumentDataFieldName *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Indicates whether Amazon Kendra should crawl attachments to the service catalog
                                                                                                                                                                                                                                                                  	// items.
                                                                                                                                                                                                                                                                  	CrawlAttachments bool
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// The name of the ServiceNow field that is mapped to the index document title
                                                                                                                                                                                                                                                                  	// field.
                                                                                                                                                                                                                                                                  	DocumentTitleFieldName *string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Determines the types of file attachments that are excluded from the index.
                                                                                                                                                                                                                                                                  	ExcludeAttachmentFilePatterns []string
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Mapping between ServiceNow fields and Amazon Kendra index fields. You must
                                                                                                                                                                                                                                                                  	// create the index field before you map the field.
                                                                                                                                                                                                                                                                  	FieldMappings []DataSourceToIndexFieldMapping
                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                  	// Determines the types of file attachments that are included in the index.
                                                                                                                                                                                                                                                                  	IncludeAttachmentFilePatterns []string
                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                    Provides configuration information for crawling service catalog items in the ServiceNow site

                                                                                                                                                                                                                                                                    type ServiceQuotaExceededException

                                                                                                                                                                                                                                                                    type ServiceQuotaExceededException struct {
                                                                                                                                                                                                                                                                    	Message *string
                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                    func (*ServiceQuotaExceededException) Error

                                                                                                                                                                                                                                                                    func (*ServiceQuotaExceededException) ErrorCode

                                                                                                                                                                                                                                                                    func (e *ServiceQuotaExceededException) ErrorCode() string

                                                                                                                                                                                                                                                                    func (*ServiceQuotaExceededException) ErrorFault

                                                                                                                                                                                                                                                                    func (*ServiceQuotaExceededException) ErrorMessage

                                                                                                                                                                                                                                                                    func (e *ServiceQuotaExceededException) ErrorMessage() string

                                                                                                                                                                                                                                                                    type SharePointConfiguration

                                                                                                                                                                                                                                                                    type SharePointConfiguration struct {
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// The Amazon Resource Name (ARN) of credentials stored in AWS Secrets Manager. The
                                                                                                                                                                                                                                                                    	// credentials should be a user/password pair. For more information, see Using a
                                                                                                                                                                                                                                                                    	// Microsoft SharePoint Data Source
                                                                                                                                                                                                                                                                    	// (https://docs.aws.amazon.com/kendra/latest/dg/data-source-sharepoint.html). For
                                                                                                                                                                                                                                                                    	// more information about AWS Secrets Manager, see  What Is AWS Secrets Manager
                                                                                                                                                                                                                                                                    	// (https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) in the
                                                                                                                                                                                                                                                                    	// AWS Secrets Manager user guide.
                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                    	SecretArn *string
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// The version of Microsoft SharePoint that you are using as a data source.
                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                    	SharePointVersion SharePointVersion
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// The URLs of the Microsoft SharePoint site that contains the documents that
                                                                                                                                                                                                                                                                    	// should be indexed.
                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                    	Urls []string
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// TRUE to include attachments to documents stored in your Microsoft SharePoint
                                                                                                                                                                                                                                                                    	// site in the index; otherwise, FALSE.
                                                                                                                                                                                                                                                                    	CrawlAttachments bool
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// A Boolean value that specifies whether local groups are disabled (True) or
                                                                                                                                                                                                                                                                    	// enabled (False).
                                                                                                                                                                                                                                                                    	DisableLocalGroups bool
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// The Microsoft SharePoint attribute field that contains the title of the
                                                                                                                                                                                                                                                                    	// document.
                                                                                                                                                                                                                                                                    	DocumentTitleFieldName *string
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// A list of regular expression patterns. Documents that match the patterns are
                                                                                                                                                                                                                                                                    	// excluded from the index. Documents that don't match the patterns are included in
                                                                                                                                                                                                                                                                    	// the index. If a document matches both an exclusion pattern and an inclusion
                                                                                                                                                                                                                                                                    	// pattern, the document is not included in the index. The regex is applied to the
                                                                                                                                                                                                                                                                    	// display URL of the SharePoint document.
                                                                                                                                                                                                                                                                    	ExclusionPatterns []string
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// A list of DataSourceToIndexFieldMapping objects that map Microsoft SharePoint
                                                                                                                                                                                                                                                                    	// attributes to custom fields in the Amazon Kendra index. You must first create
                                                                                                                                                                                                                                                                    	// the index fields using the operation before you map SharePoint attributes. For
                                                                                                                                                                                                                                                                    	// more information, see Mapping Data Source Fields
                                                                                                                                                                                                                                                                    	// (https://docs.aws.amazon.com/kendra/latest/dg/field-mapping.html).
                                                                                                                                                                                                                                                                    	FieldMappings []DataSourceToIndexFieldMapping
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// A list of regular expression patterns. Documents that match the patterns are
                                                                                                                                                                                                                                                                    	// included in the index. Documents that don't match the patterns are excluded from
                                                                                                                                                                                                                                                                    	// the index. If a document matches both an inclusion pattern and an exclusion
                                                                                                                                                                                                                                                                    	// pattern, the document is not included in the index. The regex is applied to the
                                                                                                                                                                                                                                                                    	// display URL of the SharePoint document.
                                                                                                                                                                                                                                                                    	InclusionPatterns []string
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// Set to TRUE to use the Microsoft SharePoint change log to determine the
                                                                                                                                                                                                                                                                    	// documents that need to be updated in the index. Depending on the size of the
                                                                                                                                                                                                                                                                    	// SharePoint change log, it may take longer for Amazon Kendra to use the change
                                                                                                                                                                                                                                                                    	// log than it takes it to determine the changed documents using the Amazon Kendra
                                                                                                                                                                                                                                                                    	// document crawler.
                                                                                                                                                                                                                                                                    	UseChangeLog bool
                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                    	// Provides information for connecting to an Amazon VPC.
                                                                                                                                                                                                                                                                    	VpcConfiguration *DataSourceVpcConfiguration
                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                      Provides configuration information for connecting to a Microsoft SharePoint data source.

                                                                                                                                                                                                                                                                      type SharePointVersion

                                                                                                                                                                                                                                                                      type SharePointVersion string
                                                                                                                                                                                                                                                                      const (
                                                                                                                                                                                                                                                                      	SharePointVersionSharepointOnline SharePointVersion = "SHAREPOINT_ONLINE"
                                                                                                                                                                                                                                                                      )

                                                                                                                                                                                                                                                                        Enum values for SharePointVersion

                                                                                                                                                                                                                                                                        func (SharePointVersion) Values

                                                                                                                                                                                                                                                                          Values returns all known values for SharePointVersion. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                          type SortOrder

                                                                                                                                                                                                                                                                          type SortOrder string
                                                                                                                                                                                                                                                                          const (
                                                                                                                                                                                                                                                                          	SortOrderDesc SortOrder = "DESC"
                                                                                                                                                                                                                                                                          	SortOrderAsc  SortOrder = "ASC"
                                                                                                                                                                                                                                                                          )

                                                                                                                                                                                                                                                                            Enum values for SortOrder

                                                                                                                                                                                                                                                                            func (SortOrder) Values

                                                                                                                                                                                                                                                                            func (SortOrder) Values() []SortOrder

                                                                                                                                                                                                                                                                              Values returns all known values for SortOrder. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                              type SortingConfiguration

                                                                                                                                                                                                                                                                              type SortingConfiguration struct {
                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                              	// The name of the document attribute used to sort the response. You can use any
                                                                                                                                                                                                                                                                              	// field that has the Sortable flag set to true. You can also sort by any of the
                                                                                                                                                                                                                                                                              	// following built-in attributes:
                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                              	// * _category
                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                              	// * _created_at
                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                              	// *
                                                                                                                                                                                                                                                                              	// _last_updated_at
                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                              	// * _version
                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                              	// * _view_count
                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                              	DocumentAttributeKey *string
                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                              	// The order that the results should be returned in. In case of ties, the relevance
                                                                                                                                                                                                                                                                              	// assigned to the result by Amazon Kendra is used as the tie-breaker.
                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                              	// This member is required.
                                                                                                                                                                                                                                                                              	SortOrder SortOrder
                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                Specifies the document attribute to use to sort the response to a Amazon Kendra query. You can specify a single attribute for sorting. The attribute must have the Sortable flag set to true, otherwise Amazon Kendra returns an exception. You can sort attributes of the following types.

                                                                                                                                                                                                                                                                                * Date value

                                                                                                                                                                                                                                                                                * Long value

                                                                                                                                                                                                                                                                                * String value

                                                                                                                                                                                                                                                                                You can't sort attributes of the following type.

                                                                                                                                                                                                                                                                                * String list value

                                                                                                                                                                                                                                                                                type SqlConfiguration

                                                                                                                                                                                                                                                                                type SqlConfiguration struct {
                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                	// Determines whether Amazon Kendra encloses SQL identifiers for tables and column
                                                                                                                                                                                                                                                                                	// names in double quotes (") when making a database query. By default, Amazon
                                                                                                                                                                                                                                                                                	// Kendra passes SQL identifiers the way that they are entered into the data source
                                                                                                                                                                                                                                                                                	// configuration. It does not change the case of identifiers or enclose them in
                                                                                                                                                                                                                                                                                	// quotes. PostgreSQL internally converts uppercase characters to lower case
                                                                                                                                                                                                                                                                                	// characters in identifiers unless they are quoted. Choosing this option encloses
                                                                                                                                                                                                                                                                                	// identifiers in quotes so that PostgreSQL does not convert the character's case.
                                                                                                                                                                                                                                                                                	// For MySQL databases, you must enable the ansi_quotes option when you set this
                                                                                                                                                                                                                                                                                	// field to DOUBLE_QUOTES.
                                                                                                                                                                                                                                                                                	QueryIdentifiersEnclosingOption QueryIdentifiersEnclosingOption
                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                  Provides information that configures Amazon Kendra to use a SQL database.

                                                                                                                                                                                                                                                                                  type Tag

                                                                                                                                                                                                                                                                                  type Tag struct {
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// The key for the tag. Keys are not case sensitive and must be unique for the
                                                                                                                                                                                                                                                                                  	// index, FAQ, or data source.
                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                  	Key *string
                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                  	// The value associated with the tag. The value may be an empty string but it can't
                                                                                                                                                                                                                                                                                  	// be null.
                                                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                                                  	// This member is required.
                                                                                                                                                                                                                                                                                  	Value *string
                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                    A list of key/value pairs that identify an index, FAQ, or data source. Tag keys and values can consist of Unicode letters, digits, white space, and any of the following symbols: _ . : / = + - @.

                                                                                                                                                                                                                                                                                    type TextDocumentStatistics

                                                                                                                                                                                                                                                                                    type TextDocumentStatistics struct {
                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                    	// The total size, in bytes, of the indexed documents.
                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                    	IndexedTextBytes int64
                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                    	// The number of text documents indexed.
                                                                                                                                                                                                                                                                                    	//
                                                                                                                                                                                                                                                                                    	// This member is required.
                                                                                                                                                                                                                                                                                    	IndexedTextDocumentsCount int32
                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                      Provides information about text documents indexed in an index.

                                                                                                                                                                                                                                                                                      type TextWithHighlights

                                                                                                                                                                                                                                                                                      type TextWithHighlights struct {
                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                      	// The beginning and end of the text that should be highlighted.
                                                                                                                                                                                                                                                                                      	Highlights []Highlight
                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                      	// The text to display to the user.
                                                                                                                                                                                                                                                                                      	Text *string
                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                        Provides text and information about where to highlight the text.

                                                                                                                                                                                                                                                                                        type ThesaurusStatus

                                                                                                                                                                                                                                                                                        type ThesaurusStatus string
                                                                                                                                                                                                                                                                                        const (
                                                                                                                                                                                                                                                                                        	ThesaurusStatusCreating              ThesaurusStatus = "CREATING"
                                                                                                                                                                                                                                                                                        	ThesaurusStatusActive                ThesaurusStatus = "ACTIVE"
                                                                                                                                                                                                                                                                                        	ThesaurusStatusDeleting              ThesaurusStatus = "DELETING"
                                                                                                                                                                                                                                                                                        	ThesaurusStatusUpdating              ThesaurusStatus = "UPDATING"
                                                                                                                                                                                                                                                                                        	ThesaurusStatusActiveButUpdateFailed ThesaurusStatus = "ACTIVE_BUT_UPDATE_FAILED"
                                                                                                                                                                                                                                                                                        	ThesaurusStatusFailed                ThesaurusStatus = "FAILED"
                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                          Enum values for ThesaurusStatus

                                                                                                                                                                                                                                                                                          func (ThesaurusStatus) Values

                                                                                                                                                                                                                                                                                          func (ThesaurusStatus) Values() []ThesaurusStatus

                                                                                                                                                                                                                                                                                            Values returns all known values for ThesaurusStatus. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                            type ThesaurusSummary

                                                                                                                                                                                                                                                                                            type ThesaurusSummary struct {
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// The Unix datetime that the thesaurus was created.
                                                                                                                                                                                                                                                                                            	CreatedAt *time.Time
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// The identifier of the thesaurus.
                                                                                                                                                                                                                                                                                            	Id *string
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// The name of the thesaurus.
                                                                                                                                                                                                                                                                                            	Name *string
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// The status of the thesaurus.
                                                                                                                                                                                                                                                                                            	Status ThesaurusStatus
                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                            	// The Unix datetime that the thesaurus was last updated.
                                                                                                                                                                                                                                                                                            	UpdatedAt *time.Time
                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                              An array of summary information for one or more thesauruses.

                                                                                                                                                                                                                                                                                              type ThrottlingException

                                                                                                                                                                                                                                                                                              type ThrottlingException struct {
                                                                                                                                                                                                                                                                                              	Message *string
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                              func (*ThrottlingException) Error

                                                                                                                                                                                                                                                                                              func (e *ThrottlingException) Error() string

                                                                                                                                                                                                                                                                                              func (*ThrottlingException) ErrorCode

                                                                                                                                                                                                                                                                                              func (e *ThrottlingException) ErrorCode() string

                                                                                                                                                                                                                                                                                              func (*ThrottlingException) ErrorFault

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

                                                                                                                                                                                                                                                                                              func (*ThrottlingException) ErrorMessage

                                                                                                                                                                                                                                                                                              func (e *ThrottlingException) ErrorMessage() string

                                                                                                                                                                                                                                                                                              type TimeRange

                                                                                                                                                                                                                                                                                              type TimeRange struct {
                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                              	// The UNIX datetime of the end of the time range.
                                                                                                                                                                                                                                                                                              	EndTime *time.Time
                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                              	// The UNIX datetime of the beginning of the time range.
                                                                                                                                                                                                                                                                                              	StartTime *time.Time
                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                Provides a range of time.

                                                                                                                                                                                                                                                                                                type UnknownUnionMember

                                                                                                                                                                                                                                                                                                type UnknownUnionMember struct {
                                                                                                                                                                                                                                                                                                	Tag   string
                                                                                                                                                                                                                                                                                                	Value []byte
                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                  UnknownUnionMember is returned when a union member is returned over the wire, but has an unknown tag.

                                                                                                                                                                                                                                                                                                  type UserContext

                                                                                                                                                                                                                                                                                                  type UserContext struct {
                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                  	// The user context token. It must be a JWT or a JSON token.
                                                                                                                                                                                                                                                                                                  	Token *string
                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                    Provides information about the user context for a Amazon Kendra index.

                                                                                                                                                                                                                                                                                                    type UserContextPolicy

                                                                                                                                                                                                                                                                                                    type UserContextPolicy string
                                                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                                                    	UserContextPolicyAttributeFilter UserContextPolicy = "ATTRIBUTE_FILTER"
                                                                                                                                                                                                                                                                                                    	UserContextPolicyUserToken       UserContextPolicy = "USER_TOKEN"
                                                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                                                      Enum values for UserContextPolicy

                                                                                                                                                                                                                                                                                                      func (UserContextPolicy) Values

                                                                                                                                                                                                                                                                                                        Values returns all known values for UserContextPolicy. Note that this can be expanded in the future, and so it is only as up to date as the client. The ordering of this slice is not guaranteed to be stable across updates.

                                                                                                                                                                                                                                                                                                        type UserTokenConfiguration

                                                                                                                                                                                                                                                                                                        type UserTokenConfiguration struct {
                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                        	// Information about the JSON token type configuration.
                                                                                                                                                                                                                                                                                                        	JsonTokenTypeConfiguration *JsonTokenTypeConfiguration
                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                        	// Information about the JWT token type configuration.
                                                                                                                                                                                                                                                                                                        	JwtTokenTypeConfiguration *JwtTokenTypeConfiguration
                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                          Provides configuration information for a token configuration.

                                                                                                                                                                                                                                                                                                          type ValidationException

                                                                                                                                                                                                                                                                                                          type ValidationException struct {
                                                                                                                                                                                                                                                                                                          	Message *string
                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                          func (*ValidationException) Error

                                                                                                                                                                                                                                                                                                          func (e *ValidationException) Error() string

                                                                                                                                                                                                                                                                                                          func (*ValidationException) ErrorCode

                                                                                                                                                                                                                                                                                                          func (e *ValidationException) ErrorCode() string

                                                                                                                                                                                                                                                                                                          func (*ValidationException) ErrorFault

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

                                                                                                                                                                                                                                                                                                          func (*ValidationException) ErrorMessage

                                                                                                                                                                                                                                                                                                          func (e *ValidationException) ErrorMessage() string