use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::proto;
use rusoto_core::request::HttpResponse;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
impl KendraClient {
fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
let mut request = SignedRequest::new(http_method, "kendra", &self.region, request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request
}
async fn sign_and_dispatch<E>(
&self,
request: SignedRequest,
from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
) -> Result<HttpResponse, RusotoError<E>> {
let mut response = self.client.sign_and_dispatch(request).await?;
if !response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
return Err(from_response(response));
}
Ok(response)
}
}
use serde_json;
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AccessControlListConfiguration {
#[serde(rename = "KeyPath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key_path: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AclConfiguration {
#[serde(rename = "AllowedGroupsColumnName")]
pub allowed_groups_column_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdditionalResultAttribute {
#[serde(rename = "Key")]
pub key: String,
#[serde(rename = "Value")]
pub value: AdditionalResultAttributeValue,
#[serde(rename = "ValueType")]
pub value_type: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdditionalResultAttributeValue {
#[serde(rename = "TextWithHighlightsValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub text_with_highlights_value: Option<TextWithHighlights>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AttributeFilter {
#[serde(rename = "AndAllFilters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub and_all_filters: Option<Vec<AttributeFilter>>,
#[serde(rename = "ContainsAll")]
#[serde(skip_serializing_if = "Option::is_none")]
pub contains_all: Option<DocumentAttribute>,
#[serde(rename = "ContainsAny")]
#[serde(skip_serializing_if = "Option::is_none")]
pub contains_any: Option<DocumentAttribute>,
#[serde(rename = "EqualsTo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub equals_to: Option<DocumentAttribute>,
#[serde(rename = "GreaterThan")]
#[serde(skip_serializing_if = "Option::is_none")]
pub greater_than: Option<DocumentAttribute>,
#[serde(rename = "GreaterThanOrEquals")]
#[serde(skip_serializing_if = "Option::is_none")]
pub greater_than_or_equals: Option<DocumentAttribute>,
#[serde(rename = "LessThan")]
#[serde(skip_serializing_if = "Option::is_none")]
pub less_than: Option<DocumentAttribute>,
#[serde(rename = "LessThanOrEquals")]
#[serde(skip_serializing_if = "Option::is_none")]
pub less_than_or_equals: Option<DocumentAttribute>,
#[serde(rename = "NotFilter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub not_filter: Box<Option<AttributeFilter>>,
#[serde(rename = "OrAllFilters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub or_all_filters: Option<Vec<AttributeFilter>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchDeleteDocumentRequest {
#[serde(rename = "DataSourceSyncJobMetricTarget")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_source_sync_job_metric_target: Option<DataSourceSyncJobMetricTarget>,
#[serde(rename = "DocumentIdList")]
pub document_id_list: Vec<String>,
#[serde(rename = "IndexId")]
pub index_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchDeleteDocumentResponse {
#[serde(rename = "FailedDocuments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed_documents: Option<Vec<BatchDeleteDocumentResponseFailedDocument>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchDeleteDocumentResponseFailedDocument {
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchPutDocumentRequest {
#[serde(rename = "Documents")]
pub documents: Vec<Document>,
#[serde(rename = "IndexId")]
pub index_id: String,
#[serde(rename = "RoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchPutDocumentResponse {
#[serde(rename = "FailedDocuments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed_documents: Option<Vec<BatchPutDocumentResponseFailedDocument>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchPutDocumentResponseFailedDocument {
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CapacityUnitsConfiguration {
#[serde(rename = "QueryCapacityUnits")]
pub query_capacity_units: i64,
#[serde(rename = "StorageCapacityUnits")]
pub storage_capacity_units: i64,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ClickFeedback {
#[serde(rename = "ClickTime")]
pub click_time: f64,
#[serde(rename = "ResultId")]
pub result_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ColumnConfiguration {
#[serde(rename = "ChangeDetectingColumns")]
pub change_detecting_columns: Vec<String>,
#[serde(rename = "DocumentDataColumnName")]
pub document_data_column_name: String,
#[serde(rename = "DocumentIdColumnName")]
pub document_id_column_name: String,
#[serde(rename = "DocumentTitleColumnName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub document_title_column_name: Option<String>,
#[serde(rename = "FieldMappings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub field_mappings: Option<Vec<DataSourceToIndexFieldMapping>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ConfluenceAttachmentConfiguration {
#[serde(rename = "AttachmentFieldMappings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attachment_field_mappings: Option<Vec<ConfluenceAttachmentToIndexFieldMapping>>,
#[serde(rename = "CrawlAttachments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub crawl_attachments: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ConfluenceAttachmentToIndexFieldMapping {
#[serde(rename = "DataSourceFieldName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_source_field_name: Option<String>,
#[serde(rename = "DateFieldFormat")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date_field_format: Option<String>,
#[serde(rename = "IndexFieldName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub index_field_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ConfluenceBlogConfiguration {
#[serde(rename = "BlogFieldMappings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub blog_field_mappings: Option<Vec<ConfluenceBlogToIndexFieldMapping>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ConfluenceBlogToIndexFieldMapping {
#[serde(rename = "DataSourceFieldName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_source_field_name: Option<String>,
#[serde(rename = "DateFieldFormat")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date_field_format: Option<String>,
#[serde(rename = "IndexFieldName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub index_field_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ConfluenceConfiguration {
#[serde(rename = "AttachmentConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attachment_configuration: Option<ConfluenceAttachmentConfiguration>,
#[serde(rename = "BlogConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub blog_configuration: Option<ConfluenceBlogConfiguration>,
#[serde(rename = "ExclusionPatterns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub exclusion_patterns: Option<Vec<String>>,
#[serde(rename = "InclusionPatterns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub inclusion_patterns: Option<Vec<String>>,
#[serde(rename = "PageConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_configuration: Option<ConfluencePageConfiguration>,
#[serde(rename = "SecretArn")]
pub secret_arn: String,
#[serde(rename = "ServerUrl")]
pub server_url: String,
#[serde(rename = "SpaceConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub space_configuration: Option<ConfluenceSpaceConfiguration>,
#[serde(rename = "Version")]
pub version: String,
#[serde(rename = "VpcConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_configuration: Option<DataSourceVpcConfiguration>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ConfluencePageConfiguration {
#[serde(rename = "PageFieldMappings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_field_mappings: Option<Vec<ConfluencePageToIndexFieldMapping>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ConfluencePageToIndexFieldMapping {
#[serde(rename = "DataSourceFieldName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_source_field_name: Option<String>,
#[serde(rename = "DateFieldFormat")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date_field_format: Option<String>,
#[serde(rename = "IndexFieldName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub index_field_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ConfluenceSpaceConfiguration {
#[serde(rename = "CrawlArchivedSpaces")]
#[serde(skip_serializing_if = "Option::is_none")]
pub crawl_archived_spaces: Option<bool>,
#[serde(rename = "CrawlPersonalSpaces")]
#[serde(skip_serializing_if = "Option::is_none")]
pub crawl_personal_spaces: Option<bool>,
#[serde(rename = "ExcludeSpaces")]
#[serde(skip_serializing_if = "Option::is_none")]
pub exclude_spaces: Option<Vec<String>>,
#[serde(rename = "IncludeSpaces")]
#[serde(skip_serializing_if = "Option::is_none")]
pub include_spaces: Option<Vec<String>>,
#[serde(rename = "SpaceFieldMappings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub space_field_mappings: Option<Vec<ConfluenceSpaceToIndexFieldMapping>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ConfluenceSpaceToIndexFieldMapping {
#[serde(rename = "DataSourceFieldName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_source_field_name: Option<String>,
#[serde(rename = "DateFieldFormat")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date_field_format: Option<String>,
#[serde(rename = "IndexFieldName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub index_field_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ConnectionConfiguration {
#[serde(rename = "DatabaseHost")]
pub database_host: String,
#[serde(rename = "DatabaseName")]
pub database_name: String,
#[serde(rename = "DatabasePort")]
pub database_port: i64,
#[serde(rename = "SecretArn")]
pub secret_arn: String,
#[serde(rename = "TableName")]
pub table_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDataSourceRequest {
#[serde(rename = "ClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "Configuration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration: Option<DataSourceConfiguration>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "IndexId")]
pub index_id: String,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "RoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
#[serde(rename = "Schedule")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schedule: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "Type")]
pub type_: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDataSourceResponse {
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateFaqRequest {
#[serde(rename = "ClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "FileFormat")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_format: Option<String>,
#[serde(rename = "IndexId")]
pub index_id: String,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "RoleArn")]
pub role_arn: String,
#[serde(rename = "S3Path")]
pub s3_path: S3Path,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateFaqResponse {
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateIndexRequest {
#[serde(rename = "ClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Edition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub edition: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "RoleArn")]
pub role_arn: String,
#[serde(rename = "ServerSideEncryptionConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_side_encryption_configuration: Option<ServerSideEncryptionConfiguration>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "UserContextPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_context_policy: Option<String>,
#[serde(rename = "UserTokenConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_token_configurations: Option<Vec<UserTokenConfiguration>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateIndexResponse {
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateThesaurusRequest {
#[serde(rename = "ClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "IndexId")]
pub index_id: String,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "RoleArn")]
pub role_arn: String,
#[serde(rename = "SourceS3Path")]
pub source_s3_path: S3Path,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateThesaurusResponse {
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DataSourceConfiguration {
#[serde(rename = "ConfluenceConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub confluence_configuration: Option<ConfluenceConfiguration>,
#[serde(rename = "DatabaseConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub database_configuration: Option<DatabaseConfiguration>,
#[serde(rename = "GoogleDriveConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub google_drive_configuration: Option<GoogleDriveConfiguration>,
#[serde(rename = "OneDriveConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub one_drive_configuration: Option<OneDriveConfiguration>,
#[serde(rename = "S3Configuration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_configuration: Option<S3DataSourceConfiguration>,
#[serde(rename = "SalesforceConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub salesforce_configuration: Option<SalesforceConfiguration>,
#[serde(rename = "ServiceNowConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_now_configuration: Option<ServiceNowConfiguration>,
#[serde(rename = "SharePointConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub share_point_configuration: Option<SharePointConfiguration>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DataSourceSummary {
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "UpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub updated_at: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DataSourceSyncJob {
#[serde(rename = "DataSourceErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_source_error_code: Option<String>,
#[serde(rename = "EndTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_time: Option<f64>,
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "ExecutionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub execution_id: Option<String>,
#[serde(rename = "Metrics")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metrics: Option<DataSourceSyncJobMetrics>,
#[serde(rename = "StartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DataSourceSyncJobMetricTarget {
#[serde(rename = "DataSourceId")]
pub data_source_id: String,
#[serde(rename = "DataSourceSyncJobId")]
pub data_source_sync_job_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DataSourceSyncJobMetrics {
#[serde(rename = "DocumentsAdded")]
#[serde(skip_serializing_if = "Option::is_none")]
pub documents_added: Option<String>,
#[serde(rename = "DocumentsDeleted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub documents_deleted: Option<String>,
#[serde(rename = "DocumentsFailed")]
#[serde(skip_serializing_if = "Option::is_none")]
pub documents_failed: Option<String>,
#[serde(rename = "DocumentsModified")]
#[serde(skip_serializing_if = "Option::is_none")]
pub documents_modified: Option<String>,
#[serde(rename = "DocumentsScanned")]
#[serde(skip_serializing_if = "Option::is_none")]
pub documents_scanned: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DataSourceToIndexFieldMapping {
#[serde(rename = "DataSourceFieldName")]
pub data_source_field_name: String,
#[serde(rename = "DateFieldFormat")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date_field_format: Option<String>,
#[serde(rename = "IndexFieldName")]
pub index_field_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DataSourceVpcConfiguration {
#[serde(rename = "SecurityGroupIds")]
pub security_group_ids: Vec<String>,
#[serde(rename = "SubnetIds")]
pub subnet_ids: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DatabaseConfiguration {
#[serde(rename = "AclConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub acl_configuration: Option<AclConfiguration>,
#[serde(rename = "ColumnConfiguration")]
pub column_configuration: ColumnConfiguration,
#[serde(rename = "ConnectionConfiguration")]
pub connection_configuration: ConnectionConfiguration,
#[serde(rename = "DatabaseEngineType")]
pub database_engine_type: String,
#[serde(rename = "SqlConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sql_configuration: Option<SqlConfiguration>,
#[serde(rename = "VpcConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_configuration: Option<DataSourceVpcConfiguration>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDataSourceRequest {
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "IndexId")]
pub index_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteFaqRequest {
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "IndexId")]
pub index_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteIndexRequest {
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteThesaurusRequest {
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "IndexId")]
pub index_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeDataSourceRequest {
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "IndexId")]
pub index_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeDataSourceResponse {
#[serde(rename = "Configuration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration: Option<DataSourceConfiguration>,
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "IndexId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub index_id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "RoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
#[serde(rename = "Schedule")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schedule: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "UpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub updated_at: Option<f64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeFaqRequest {
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "IndexId")]
pub index_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeFaqResponse {
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "FileFormat")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_format: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "IndexId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub index_id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "RoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
#[serde(rename = "S3Path")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_path: Option<S3Path>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "UpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub updated_at: Option<f64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeIndexRequest {
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeIndexResponse {
#[serde(rename = "CapacityUnits")]
#[serde(skip_serializing_if = "Option::is_none")]
pub capacity_units: Option<CapacityUnitsConfiguration>,
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DocumentMetadataConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub document_metadata_configurations: Option<Vec<DocumentMetadataConfiguration>>,
#[serde(rename = "Edition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub edition: Option<String>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "IndexStatistics")]
#[serde(skip_serializing_if = "Option::is_none")]
pub index_statistics: Option<IndexStatistics>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "RoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
#[serde(rename = "ServerSideEncryptionConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_side_encryption_configuration: Option<ServerSideEncryptionConfiguration>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "UpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub updated_at: Option<f64>,
#[serde(rename = "UserContextPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_context_policy: Option<String>,
#[serde(rename = "UserTokenConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_token_configurations: Option<Vec<UserTokenConfiguration>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeThesaurusRequest {
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "IndexId")]
pub index_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeThesaurusResponse {
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "FileSizeBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_size_bytes: Option<i64>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "IndexId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub index_id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "RoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
#[serde(rename = "SourceS3Path")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_s3_path: Option<S3Path>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "SynonymRuleCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub synonym_rule_count: Option<i64>,
#[serde(rename = "TermCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub term_count: Option<i64>,
#[serde(rename = "UpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub updated_at: Option<f64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Document {
#[serde(rename = "AccessControlList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_control_list: Option<Vec<Principal>>,
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<Vec<DocumentAttribute>>,
#[serde(rename = "Blob")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlob::deserialize_blob",
serialize_with = "::rusoto_core::serialization::SerdeBlob::serialize_blob",
default
)]
#[serde(skip_serializing_if = "Option::is_none")]
pub blob: Option<bytes::Bytes>,
#[serde(rename = "ContentType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_type: Option<String>,
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "S3Path")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_path: Option<S3Path>,
#[serde(rename = "Title")]
#[serde(skip_serializing_if = "Option::is_none")]
pub title: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DocumentAttribute {
#[serde(rename = "Key")]
pub key: String,
#[serde(rename = "Value")]
pub value: DocumentAttributeValue,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DocumentAttributeValue {
#[serde(rename = "DateValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date_value: Option<f64>,
#[serde(rename = "LongValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub long_value: Option<i64>,
#[serde(rename = "StringListValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub string_list_value: Option<Vec<String>>,
#[serde(rename = "StringValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub string_value: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DocumentAttributeValueCountPair {
#[serde(rename = "Count")]
#[serde(skip_serializing_if = "Option::is_none")]
pub count: Option<i64>,
#[serde(rename = "DocumentAttributeValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub document_attribute_value: Option<DocumentAttributeValue>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DocumentMetadataConfiguration {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Relevance")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relevance: Option<Relevance>,
#[serde(rename = "Search")]
#[serde(skip_serializing_if = "Option::is_none")]
pub search: Option<Search>,
#[serde(rename = "Type")]
pub type_: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DocumentsMetadataConfiguration {
#[serde(rename = "S3Prefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_prefix: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Facet {
#[serde(rename = "DocumentAttributeKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub document_attribute_key: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FacetResult {
#[serde(rename = "DocumentAttributeKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub document_attribute_key: Option<String>,
#[serde(rename = "DocumentAttributeValueCountPairs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub document_attribute_value_count_pairs: Option<Vec<DocumentAttributeValueCountPair>>,
#[serde(rename = "DocumentAttributeValueType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub document_attribute_value_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FaqStatistics {
#[serde(rename = "IndexedQuestionAnswersCount")]
pub indexed_question_answers_count: i64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FaqSummary {
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "FileFormat")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_format: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "UpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub updated_at: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct GoogleDriveConfiguration {
#[serde(rename = "ExcludeMimeTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub exclude_mime_types: Option<Vec<String>>,
#[serde(rename = "ExcludeSharedDrives")]
#[serde(skip_serializing_if = "Option::is_none")]
pub exclude_shared_drives: Option<Vec<String>>,
#[serde(rename = "ExcludeUserAccounts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub exclude_user_accounts: Option<Vec<String>>,
#[serde(rename = "ExclusionPatterns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub exclusion_patterns: Option<Vec<String>>,
#[serde(rename = "FieldMappings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub field_mappings: Option<Vec<DataSourceToIndexFieldMapping>>,
#[serde(rename = "InclusionPatterns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub inclusion_patterns: Option<Vec<String>>,
#[serde(rename = "SecretArn")]
pub secret_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Highlight {
#[serde(rename = "BeginOffset")]
pub begin_offset: i64,
#[serde(rename = "EndOffset")]
pub end_offset: i64,
#[serde(rename = "TopAnswer")]
#[serde(skip_serializing_if = "Option::is_none")]
pub top_answer: Option<bool>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct IndexConfigurationSummary {
#[serde(rename = "CreatedAt")]
pub created_at: f64,
#[serde(rename = "Edition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub edition: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Status")]
pub status: String,
#[serde(rename = "UpdatedAt")]
pub updated_at: f64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct IndexStatistics {
#[serde(rename = "FaqStatistics")]
pub faq_statistics: FaqStatistics,
#[serde(rename = "TextDocumentStatistics")]
pub text_document_statistics: TextDocumentStatistics,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct JsonTokenTypeConfiguration {
#[serde(rename = "GroupAttributeField")]
pub group_attribute_field: String,
#[serde(rename = "UserNameAttributeField")]
pub user_name_attribute_field: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct JwtTokenTypeConfiguration {
#[serde(rename = "ClaimRegex")]
#[serde(skip_serializing_if = "Option::is_none")]
pub claim_regex: Option<String>,
#[serde(rename = "GroupAttributeField")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_attribute_field: Option<String>,
#[serde(rename = "Issuer")]
#[serde(skip_serializing_if = "Option::is_none")]
pub issuer: Option<String>,
#[serde(rename = "KeyLocation")]
pub key_location: String,
#[serde(rename = "SecretManagerArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub secret_manager_arn: Option<String>,
#[serde(rename = "URL")]
#[serde(skip_serializing_if = "Option::is_none")]
pub url: Option<String>,
#[serde(rename = "UserNameAttributeField")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_name_attribute_field: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDataSourceSyncJobsRequest {
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "IndexId")]
pub index_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "StartTimeFilter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time_filter: Option<TimeRange>,
#[serde(rename = "StatusFilter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_filter: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDataSourceSyncJobsResponse {
#[serde(rename = "History")]
#[serde(skip_serializing_if = "Option::is_none")]
pub history: Option<Vec<DataSourceSyncJob>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDataSourcesRequest {
#[serde(rename = "IndexId")]
pub index_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDataSourcesResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "SummaryItems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub summary_items: Option<Vec<DataSourceSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListFaqsRequest {
#[serde(rename = "IndexId")]
pub index_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListFaqsResponse {
#[serde(rename = "FaqSummaryItems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub faq_summary_items: Option<Vec<FaqSummary>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListIndicesRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListIndicesResponse {
#[serde(rename = "IndexConfigurationSummaryItems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub index_configuration_summary_items: Option<Vec<IndexConfigurationSummary>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceRequest {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceResponse {
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListThesauriRequest {
#[serde(rename = "IndexId")]
pub index_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListThesauriResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ThesaurusSummaryItems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub thesaurus_summary_items: Option<Vec<ThesaurusSummary>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct OneDriveConfiguration {
#[serde(rename = "DisableLocalGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disable_local_groups: Option<bool>,
#[serde(rename = "ExclusionPatterns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub exclusion_patterns: Option<Vec<String>>,
#[serde(rename = "FieldMappings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub field_mappings: Option<Vec<DataSourceToIndexFieldMapping>>,
#[serde(rename = "InclusionPatterns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub inclusion_patterns: Option<Vec<String>>,
#[serde(rename = "OneDriveUsers")]
pub one_drive_users: OneDriveUsers,
#[serde(rename = "SecretArn")]
pub secret_arn: String,
#[serde(rename = "TenantDomain")]
pub tenant_domain: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct OneDriveUsers {
#[serde(rename = "OneDriveUserList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub one_drive_user_list: Option<Vec<String>>,
#[serde(rename = "OneDriveUserS3Path")]
#[serde(skip_serializing_if = "Option::is_none")]
pub one_drive_user_s3_path: Option<S3Path>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Principal {
#[serde(rename = "Access")]
pub access: String,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Type")]
pub type_: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct QueryRequest {
#[serde(rename = "AttributeFilter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attribute_filter: Option<AttributeFilter>,
#[serde(rename = "Facets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub facets: Option<Vec<Facet>>,
#[serde(rename = "IndexId")]
pub index_id: String,
#[serde(rename = "PageNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_number: Option<i64>,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
#[serde(rename = "QueryResultTypeFilter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub query_result_type_filter: Option<String>,
#[serde(rename = "QueryText")]
pub query_text: String,
#[serde(rename = "RequestedDocumentAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requested_document_attributes: Option<Vec<String>>,
#[serde(rename = "SortingConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sorting_configuration: Option<SortingConfiguration>,
#[serde(rename = "UserContext")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_context: Option<UserContext>,
#[serde(rename = "VisitorId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub visitor_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct QueryResult {
#[serde(rename = "FacetResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub facet_results: Option<Vec<FacetResult>>,
#[serde(rename = "QueryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub query_id: Option<String>,
#[serde(rename = "ResultItems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub result_items: Option<Vec<QueryResultItem>>,
#[serde(rename = "TotalNumberOfResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub total_number_of_results: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct QueryResultItem {
#[serde(rename = "AdditionalAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub additional_attributes: Option<Vec<AdditionalResultAttribute>>,
#[serde(rename = "DocumentAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub document_attributes: Option<Vec<DocumentAttribute>>,
#[serde(rename = "DocumentExcerpt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub document_excerpt: Option<TextWithHighlights>,
#[serde(rename = "DocumentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub document_id: Option<String>,
#[serde(rename = "DocumentTitle")]
#[serde(skip_serializing_if = "Option::is_none")]
pub document_title: Option<TextWithHighlights>,
#[serde(rename = "DocumentURI")]
#[serde(skip_serializing_if = "Option::is_none")]
pub document_uri: Option<String>,
#[serde(rename = "FeedbackToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub feedback_token: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "ScoreAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub score_attributes: Option<ScoreAttributes>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Relevance {
#[serde(rename = "Duration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub duration: Option<String>,
#[serde(rename = "Freshness")]
#[serde(skip_serializing_if = "Option::is_none")]
pub freshness: Option<bool>,
#[serde(rename = "Importance")]
#[serde(skip_serializing_if = "Option::is_none")]
pub importance: Option<i64>,
#[serde(rename = "RankOrder")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rank_order: Option<String>,
#[serde(rename = "ValueImportanceMap")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value_importance_map: Option<::std::collections::HashMap<String, i64>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RelevanceFeedback {
#[serde(rename = "RelevanceValue")]
pub relevance_value: String,
#[serde(rename = "ResultId")]
pub result_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct S3DataSourceConfiguration {
#[serde(rename = "AccessControlListConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_control_list_configuration: Option<AccessControlListConfiguration>,
#[serde(rename = "BucketName")]
pub bucket_name: String,
#[serde(rename = "DocumentsMetadataConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub documents_metadata_configuration: Option<DocumentsMetadataConfiguration>,
#[serde(rename = "ExclusionPatterns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub exclusion_patterns: Option<Vec<String>>,
#[serde(rename = "InclusionPatterns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub inclusion_patterns: Option<Vec<String>>,
#[serde(rename = "InclusionPrefixes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub inclusion_prefixes: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct S3Path {
#[serde(rename = "Bucket")]
pub bucket: String,
#[serde(rename = "Key")]
pub key: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SalesforceChatterFeedConfiguration {
#[serde(rename = "DocumentDataFieldName")]
pub document_data_field_name: String,
#[serde(rename = "DocumentTitleFieldName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub document_title_field_name: Option<String>,
#[serde(rename = "FieldMappings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub field_mappings: Option<Vec<DataSourceToIndexFieldMapping>>,
#[serde(rename = "IncludeFilterTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub include_filter_types: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SalesforceConfiguration {
#[serde(rename = "ChatterFeedConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub chatter_feed_configuration: Option<SalesforceChatterFeedConfiguration>,
#[serde(rename = "CrawlAttachments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub crawl_attachments: Option<bool>,
#[serde(rename = "ExcludeAttachmentFilePatterns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub exclude_attachment_file_patterns: Option<Vec<String>>,
#[serde(rename = "IncludeAttachmentFilePatterns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub include_attachment_file_patterns: Option<Vec<String>>,
#[serde(rename = "KnowledgeArticleConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub knowledge_article_configuration: Option<SalesforceKnowledgeArticleConfiguration>,
#[serde(rename = "SecretArn")]
pub secret_arn: String,
#[serde(rename = "ServerUrl")]
pub server_url: String,
#[serde(rename = "StandardObjectAttachmentConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub standard_object_attachment_configuration:
Option<SalesforceStandardObjectAttachmentConfiguration>,
#[serde(rename = "StandardObjectConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub standard_object_configurations: Option<Vec<SalesforceStandardObjectConfiguration>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SalesforceCustomKnowledgeArticleTypeConfiguration {
#[serde(rename = "DocumentDataFieldName")]
pub document_data_field_name: String,
#[serde(rename = "DocumentTitleFieldName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub document_title_field_name: Option<String>,
#[serde(rename = "FieldMappings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub field_mappings: Option<Vec<DataSourceToIndexFieldMapping>>,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SalesforceKnowledgeArticleConfiguration {
#[serde(rename = "CustomKnowledgeArticleTypeConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_knowledge_article_type_configurations:
Option<Vec<SalesforceCustomKnowledgeArticleTypeConfiguration>>,
#[serde(rename = "IncludedStates")]
pub included_states: Vec<String>,
#[serde(rename = "StandardKnowledgeArticleTypeConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub standard_knowledge_article_type_configuration:
Option<SalesforceStandardKnowledgeArticleTypeConfiguration>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SalesforceStandardKnowledgeArticleTypeConfiguration {
#[serde(rename = "DocumentDataFieldName")]
pub document_data_field_name: String,
#[serde(rename = "DocumentTitleFieldName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub document_title_field_name: Option<String>,
#[serde(rename = "FieldMappings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub field_mappings: Option<Vec<DataSourceToIndexFieldMapping>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SalesforceStandardObjectAttachmentConfiguration {
#[serde(rename = "DocumentTitleFieldName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub document_title_field_name: Option<String>,
#[serde(rename = "FieldMappings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub field_mappings: Option<Vec<DataSourceToIndexFieldMapping>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SalesforceStandardObjectConfiguration {
#[serde(rename = "DocumentDataFieldName")]
pub document_data_field_name: String,
#[serde(rename = "DocumentTitleFieldName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub document_title_field_name: Option<String>,
#[serde(rename = "FieldMappings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub field_mappings: Option<Vec<DataSourceToIndexFieldMapping>>,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ScoreAttributes {
#[serde(rename = "ScoreConfidence")]
#[serde(skip_serializing_if = "Option::is_none")]
pub score_confidence: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Search {
#[serde(rename = "Displayable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub displayable: Option<bool>,
#[serde(rename = "Facetable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub facetable: Option<bool>,
#[serde(rename = "Searchable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub searchable: Option<bool>,
#[serde(rename = "Sortable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sortable: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ServerSideEncryptionConfiguration {
#[serde(rename = "KmsKeyId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ServiceNowConfiguration {
#[serde(rename = "HostUrl")]
pub host_url: String,
#[serde(rename = "KnowledgeArticleConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub knowledge_article_configuration: Option<ServiceNowKnowledgeArticleConfiguration>,
#[serde(rename = "SecretArn")]
pub secret_arn: String,
#[serde(rename = "ServiceCatalogConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_catalog_configuration: Option<ServiceNowServiceCatalogConfiguration>,
#[serde(rename = "ServiceNowBuildVersion")]
pub service_now_build_version: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ServiceNowKnowledgeArticleConfiguration {
#[serde(rename = "CrawlAttachments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub crawl_attachments: Option<bool>,
#[serde(rename = "DocumentDataFieldName")]
pub document_data_field_name: String,
#[serde(rename = "DocumentTitleFieldName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub document_title_field_name: Option<String>,
#[serde(rename = "ExcludeAttachmentFilePatterns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub exclude_attachment_file_patterns: Option<Vec<String>>,
#[serde(rename = "FieldMappings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub field_mappings: Option<Vec<DataSourceToIndexFieldMapping>>,
#[serde(rename = "IncludeAttachmentFilePatterns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub include_attachment_file_patterns: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ServiceNowServiceCatalogConfiguration {
#[serde(rename = "CrawlAttachments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub crawl_attachments: Option<bool>,
#[serde(rename = "DocumentDataFieldName")]
pub document_data_field_name: String,
#[serde(rename = "DocumentTitleFieldName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub document_title_field_name: Option<String>,
#[serde(rename = "ExcludeAttachmentFilePatterns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub exclude_attachment_file_patterns: Option<Vec<String>>,
#[serde(rename = "FieldMappings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub field_mappings: Option<Vec<DataSourceToIndexFieldMapping>>,
#[serde(rename = "IncludeAttachmentFilePatterns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub include_attachment_file_patterns: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SharePointConfiguration {
#[serde(rename = "CrawlAttachments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub crawl_attachments: Option<bool>,
#[serde(rename = "DisableLocalGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disable_local_groups: Option<bool>,
#[serde(rename = "DocumentTitleFieldName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub document_title_field_name: Option<String>,
#[serde(rename = "ExclusionPatterns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub exclusion_patterns: Option<Vec<String>>,
#[serde(rename = "FieldMappings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub field_mappings: Option<Vec<DataSourceToIndexFieldMapping>>,
#[serde(rename = "InclusionPatterns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub inclusion_patterns: Option<Vec<String>>,
#[serde(rename = "SecretArn")]
pub secret_arn: String,
#[serde(rename = "SharePointVersion")]
pub share_point_version: String,
#[serde(rename = "Urls")]
pub urls: Vec<String>,
#[serde(rename = "UseChangeLog")]
#[serde(skip_serializing_if = "Option::is_none")]
pub use_change_log: Option<bool>,
#[serde(rename = "VpcConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_configuration: Option<DataSourceVpcConfiguration>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SortingConfiguration {
#[serde(rename = "DocumentAttributeKey")]
pub document_attribute_key: String,
#[serde(rename = "SortOrder")]
pub sort_order: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SqlConfiguration {
#[serde(rename = "QueryIdentifiersEnclosingOption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub query_identifiers_enclosing_option: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartDataSourceSyncJobRequest {
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "IndexId")]
pub index_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartDataSourceSyncJobResponse {
#[serde(rename = "ExecutionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub execution_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopDataSourceSyncJobRequest {
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "IndexId")]
pub index_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SubmitFeedbackRequest {
#[serde(rename = "ClickFeedbackItems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub click_feedback_items: Option<Vec<ClickFeedback>>,
#[serde(rename = "IndexId")]
pub index_id: String,
#[serde(rename = "QueryId")]
pub query_id: String,
#[serde(rename = "RelevanceFeedbackItems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relevance_feedback_items: Option<Vec<RelevanceFeedback>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Tag {
#[serde(rename = "Key")]
pub key: String,
#[serde(rename = "Value")]
pub value: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
#[serde(rename = "Tags")]
pub tags: Vec<Tag>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TagResourceResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TextDocumentStatistics {
#[serde(rename = "IndexedTextBytes")]
pub indexed_text_bytes: i64,
#[serde(rename = "IndexedTextDocumentsCount")]
pub indexed_text_documents_count: i64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TextWithHighlights {
#[serde(rename = "Highlights")]
#[serde(skip_serializing_if = "Option::is_none")]
pub highlights: Option<Vec<Highlight>>,
#[serde(rename = "Text")]
#[serde(skip_serializing_if = "Option::is_none")]
pub text: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ThesaurusSummary {
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "UpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub updated_at: Option<f64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TimeRange {
#[serde(rename = "EndTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_time: Option<f64>,
#[serde(rename = "StartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UntagResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateDataSourceRequest {
#[serde(rename = "Configuration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration: Option<DataSourceConfiguration>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "IndexId")]
pub index_id: String,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "RoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
#[serde(rename = "Schedule")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schedule: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateIndexRequest {
#[serde(rename = "CapacityUnits")]
#[serde(skip_serializing_if = "Option::is_none")]
pub capacity_units: Option<CapacityUnitsConfiguration>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DocumentMetadataConfigurationUpdates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub document_metadata_configuration_updates: Option<Vec<DocumentMetadataConfiguration>>,
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "RoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
#[serde(rename = "UserContextPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_context_policy: Option<String>,
#[serde(rename = "UserTokenConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_token_configurations: Option<Vec<UserTokenConfiguration>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateThesaurusRequest {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "IndexId")]
pub index_id: String,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "RoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
#[serde(rename = "SourceS3Path")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_s3_path: Option<S3Path>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UserContext {
#[serde(rename = "Token")]
#[serde(skip_serializing_if = "Option::is_none")]
pub token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct UserTokenConfiguration {
#[serde(rename = "JsonTokenTypeConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub json_token_type_configuration: Option<JsonTokenTypeConfiguration>,
#[serde(rename = "JwtTokenTypeConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub jwt_token_type_configuration: Option<JwtTokenTypeConfiguration>,
}
#[derive(Debug, PartialEq)]
pub enum BatchDeleteDocumentError {
AccessDenied(String),
Conflict(String),
InternalServer(String),
ResourceNotFound(String),
Throttling(String),
}
impl BatchDeleteDocumentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<BatchDeleteDocumentError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(BatchDeleteDocumentError::AccessDenied(err.msg))
}
"ConflictException" => {
return RusotoError::Service(BatchDeleteDocumentError::Conflict(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(BatchDeleteDocumentError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(BatchDeleteDocumentError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(BatchDeleteDocumentError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BatchDeleteDocumentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchDeleteDocumentError::AccessDenied(ref cause) => write!(f, "{}", cause),
BatchDeleteDocumentError::Conflict(ref cause) => write!(f, "{}", cause),
BatchDeleteDocumentError::InternalServer(ref cause) => write!(f, "{}", cause),
BatchDeleteDocumentError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
BatchDeleteDocumentError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for BatchDeleteDocumentError {}
#[derive(Debug, PartialEq)]
pub enum BatchPutDocumentError {
AccessDenied(String),
Conflict(String),
InternalServer(String),
ResourceNotFound(String),
ServiceQuotaExceeded(String),
Throttling(String),
}
impl BatchPutDocumentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<BatchPutDocumentError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(BatchPutDocumentError::AccessDenied(err.msg))
}
"ConflictException" => {
return RusotoError::Service(BatchPutDocumentError::Conflict(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(BatchPutDocumentError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(BatchPutDocumentError::ResourceNotFound(err.msg))
}
"ServiceQuotaExceededException" => {
return RusotoError::Service(BatchPutDocumentError::ServiceQuotaExceeded(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(BatchPutDocumentError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BatchPutDocumentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchPutDocumentError::AccessDenied(ref cause) => write!(f, "{}", cause),
BatchPutDocumentError::Conflict(ref cause) => write!(f, "{}", cause),
BatchPutDocumentError::InternalServer(ref cause) => write!(f, "{}", cause),
BatchPutDocumentError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
BatchPutDocumentError::ServiceQuotaExceeded(ref cause) => write!(f, "{}", cause),
BatchPutDocumentError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for BatchPutDocumentError {}
#[derive(Debug, PartialEq)]
pub enum CreateDataSourceError {
AccessDenied(String),
Conflict(String),
InternalServer(String),
ResourceAlreadyExist(String),
ResourceNotFound(String),
ServiceQuotaExceeded(String),
Throttling(String),
}
impl CreateDataSourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDataSourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateDataSourceError::AccessDenied(err.msg))
}
"ConflictException" => {
return RusotoError::Service(CreateDataSourceError::Conflict(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(CreateDataSourceError::InternalServer(err.msg))
}
"ResourceAlreadyExistException" => {
return RusotoError::Service(CreateDataSourceError::ResourceAlreadyExist(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateDataSourceError::ResourceNotFound(err.msg))
}
"ServiceQuotaExceededException" => {
return RusotoError::Service(CreateDataSourceError::ServiceQuotaExceeded(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(CreateDataSourceError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDataSourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDataSourceError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateDataSourceError::Conflict(ref cause) => write!(f, "{}", cause),
CreateDataSourceError::InternalServer(ref cause) => write!(f, "{}", cause),
CreateDataSourceError::ResourceAlreadyExist(ref cause) => write!(f, "{}", cause),
CreateDataSourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateDataSourceError::ServiceQuotaExceeded(ref cause) => write!(f, "{}", cause),
CreateDataSourceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDataSourceError {}
#[derive(Debug, PartialEq)]
pub enum CreateFaqError {
AccessDenied(String),
Conflict(String),
InternalServer(String),
ResourceNotFound(String),
ServiceQuotaExceeded(String),
Throttling(String),
}
impl CreateFaqError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateFaqError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateFaqError::AccessDenied(err.msg))
}
"ConflictException" => {
return RusotoError::Service(CreateFaqError::Conflict(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(CreateFaqError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateFaqError::ResourceNotFound(err.msg))
}
"ServiceQuotaExceededException" => {
return RusotoError::Service(CreateFaqError::ServiceQuotaExceeded(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(CreateFaqError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateFaqError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateFaqError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateFaqError::Conflict(ref cause) => write!(f, "{}", cause),
CreateFaqError::InternalServer(ref cause) => write!(f, "{}", cause),
CreateFaqError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateFaqError::ServiceQuotaExceeded(ref cause) => write!(f, "{}", cause),
CreateFaqError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateFaqError {}
#[derive(Debug, PartialEq)]
pub enum CreateIndexError {
AccessDenied(String),
Conflict(String),
InternalServer(String),
ResourceAlreadyExist(String),
ServiceQuotaExceeded(String),
Throttling(String),
}
impl CreateIndexError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateIndexError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateIndexError::AccessDenied(err.msg))
}
"ConflictException" => {
return RusotoError::Service(CreateIndexError::Conflict(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(CreateIndexError::InternalServer(err.msg))
}
"ResourceAlreadyExistException" => {
return RusotoError::Service(CreateIndexError::ResourceAlreadyExist(err.msg))
}
"ServiceQuotaExceededException" => {
return RusotoError::Service(CreateIndexError::ServiceQuotaExceeded(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(CreateIndexError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateIndexError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateIndexError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateIndexError::Conflict(ref cause) => write!(f, "{}", cause),
CreateIndexError::InternalServer(ref cause) => write!(f, "{}", cause),
CreateIndexError::ResourceAlreadyExist(ref cause) => write!(f, "{}", cause),
CreateIndexError::ServiceQuotaExceeded(ref cause) => write!(f, "{}", cause),
CreateIndexError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateIndexError {}
#[derive(Debug, PartialEq)]
pub enum CreateThesaurusError {
AccessDenied(String),
Conflict(String),
InternalServer(String),
ResourceNotFound(String),
ServiceQuotaExceeded(String),
Throttling(String),
}
impl CreateThesaurusError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateThesaurusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateThesaurusError::AccessDenied(err.msg))
}
"ConflictException" => {
return RusotoError::Service(CreateThesaurusError::Conflict(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(CreateThesaurusError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateThesaurusError::ResourceNotFound(err.msg))
}
"ServiceQuotaExceededException" => {
return RusotoError::Service(CreateThesaurusError::ServiceQuotaExceeded(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(CreateThesaurusError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateThesaurusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateThesaurusError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateThesaurusError::Conflict(ref cause) => write!(f, "{}", cause),
CreateThesaurusError::InternalServer(ref cause) => write!(f, "{}", cause),
CreateThesaurusError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateThesaurusError::ServiceQuotaExceeded(ref cause) => write!(f, "{}", cause),
CreateThesaurusError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateThesaurusError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDataSourceError {
AccessDenied(String),
Conflict(String),
InternalServer(String),
ResourceNotFound(String),
Throttling(String),
}
impl DeleteDataSourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDataSourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteDataSourceError::AccessDenied(err.msg))
}
"ConflictException" => {
return RusotoError::Service(DeleteDataSourceError::Conflict(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(DeleteDataSourceError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteDataSourceError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DeleteDataSourceError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDataSourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDataSourceError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteDataSourceError::Conflict(ref cause) => write!(f, "{}", cause),
DeleteDataSourceError::InternalServer(ref cause) => write!(f, "{}", cause),
DeleteDataSourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteDataSourceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDataSourceError {}
#[derive(Debug, PartialEq)]
pub enum DeleteFaqError {
AccessDenied(String),
Conflict(String),
InternalServer(String),
ResourceNotFound(String),
Throttling(String),
}
impl DeleteFaqError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteFaqError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteFaqError::AccessDenied(err.msg))
}
"ConflictException" => {
return RusotoError::Service(DeleteFaqError::Conflict(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(DeleteFaqError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteFaqError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DeleteFaqError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteFaqError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteFaqError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteFaqError::Conflict(ref cause) => write!(f, "{}", cause),
DeleteFaqError::InternalServer(ref cause) => write!(f, "{}", cause),
DeleteFaqError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteFaqError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteFaqError {}
#[derive(Debug, PartialEq)]
pub enum DeleteIndexError {
AccessDenied(String),
Conflict(String),
InternalServer(String),
ResourceNotFound(String),
Throttling(String),
}
impl DeleteIndexError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteIndexError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteIndexError::AccessDenied(err.msg))
}
"ConflictException" => {
return RusotoError::Service(DeleteIndexError::Conflict(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(DeleteIndexError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteIndexError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DeleteIndexError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteIndexError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteIndexError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteIndexError::Conflict(ref cause) => write!(f, "{}", cause),
DeleteIndexError::InternalServer(ref cause) => write!(f, "{}", cause),
DeleteIndexError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteIndexError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteIndexError {}
#[derive(Debug, PartialEq)]
pub enum DeleteThesaurusError {
AccessDenied(String),
Conflict(String),
InternalServer(String),
ResourceNotFound(String),
Throttling(String),
}
impl DeleteThesaurusError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteThesaurusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteThesaurusError::AccessDenied(err.msg))
}
"ConflictException" => {
return RusotoError::Service(DeleteThesaurusError::Conflict(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(DeleteThesaurusError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteThesaurusError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DeleteThesaurusError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteThesaurusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteThesaurusError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteThesaurusError::Conflict(ref cause) => write!(f, "{}", cause),
DeleteThesaurusError::InternalServer(ref cause) => write!(f, "{}", cause),
DeleteThesaurusError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteThesaurusError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteThesaurusError {}
#[derive(Debug, PartialEq)]
pub enum DescribeDataSourceError {
AccessDenied(String),
InternalServer(String),
ResourceNotFound(String),
Throttling(String),
}
impl DescribeDataSourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeDataSourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DescribeDataSourceError::AccessDenied(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(DescribeDataSourceError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeDataSourceError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DescribeDataSourceError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeDataSourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeDataSourceError::AccessDenied(ref cause) => write!(f, "{}", cause),
DescribeDataSourceError::InternalServer(ref cause) => write!(f, "{}", cause),
DescribeDataSourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeDataSourceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeDataSourceError {}
#[derive(Debug, PartialEq)]
pub enum DescribeFaqError {
AccessDenied(String),
InternalServer(String),
ResourceNotFound(String),
Throttling(String),
}
impl DescribeFaqError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeFaqError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DescribeFaqError::AccessDenied(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(DescribeFaqError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeFaqError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DescribeFaqError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeFaqError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeFaqError::AccessDenied(ref cause) => write!(f, "{}", cause),
DescribeFaqError::InternalServer(ref cause) => write!(f, "{}", cause),
DescribeFaqError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeFaqError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeFaqError {}
#[derive(Debug, PartialEq)]
pub enum DescribeIndexError {
AccessDenied(String),
InternalServer(String),
ResourceNotFound(String),
Throttling(String),
}
impl DescribeIndexError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeIndexError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DescribeIndexError::AccessDenied(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(DescribeIndexError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeIndexError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DescribeIndexError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeIndexError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeIndexError::AccessDenied(ref cause) => write!(f, "{}", cause),
DescribeIndexError::InternalServer(ref cause) => write!(f, "{}", cause),
DescribeIndexError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeIndexError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeIndexError {}
#[derive(Debug, PartialEq)]
pub enum DescribeThesaurusError {
AccessDenied(String),
InternalServer(String),
ResourceNotFound(String),
Throttling(String),
}
impl DescribeThesaurusError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeThesaurusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DescribeThesaurusError::AccessDenied(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(DescribeThesaurusError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeThesaurusError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DescribeThesaurusError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeThesaurusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeThesaurusError::AccessDenied(ref cause) => write!(f, "{}", cause),
DescribeThesaurusError::InternalServer(ref cause) => write!(f, "{}", cause),
DescribeThesaurusError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeThesaurusError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeThesaurusError {}
#[derive(Debug, PartialEq)]
pub enum ListDataSourceSyncJobsError {
AccessDenied(String),
Conflict(String),
InternalServer(String),
ResourceNotFound(String),
Throttling(String),
}
impl ListDataSourceSyncJobsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDataSourceSyncJobsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListDataSourceSyncJobsError::AccessDenied(err.msg))
}
"ConflictException" => {
return RusotoError::Service(ListDataSourceSyncJobsError::Conflict(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(ListDataSourceSyncJobsError::InternalServer(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListDataSourceSyncJobsError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(ListDataSourceSyncJobsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDataSourceSyncJobsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDataSourceSyncJobsError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListDataSourceSyncJobsError::Conflict(ref cause) => write!(f, "{}", cause),
ListDataSourceSyncJobsError::InternalServer(ref cause) => write!(f, "{}", cause),
ListDataSourceSyncJobsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListDataSourceSyncJobsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDataSourceSyncJobsError {}
#[derive(Debug, PartialEq)]
pub enum ListDataSourcesError {
AccessDenied(String),
InternalServer(String),
ResourceNotFound(String),
Throttling(String),
}
impl ListDataSourcesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDataSourcesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListDataSourcesError::AccessDenied(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(ListDataSourcesError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListDataSourcesError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(ListDataSourcesError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDataSourcesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDataSourcesError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListDataSourcesError::InternalServer(ref cause) => write!(f, "{}", cause),
ListDataSourcesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListDataSourcesError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDataSourcesError {}
#[derive(Debug, PartialEq)]
pub enum ListFaqsError {
AccessDenied(String),
InternalServer(String),
ResourceNotFound(String),
Throttling(String),
}
impl ListFaqsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListFaqsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListFaqsError::AccessDenied(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(ListFaqsError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListFaqsError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(ListFaqsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListFaqsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListFaqsError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListFaqsError::InternalServer(ref cause) => write!(f, "{}", cause),
ListFaqsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListFaqsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListFaqsError {}
#[derive(Debug, PartialEq)]
pub enum ListIndicesError {
AccessDenied(String),
InternalServer(String),
Throttling(String),
}
impl ListIndicesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListIndicesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListIndicesError::AccessDenied(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(ListIndicesError::InternalServer(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(ListIndicesError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListIndicesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListIndicesError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListIndicesError::InternalServer(ref cause) => write!(f, "{}", cause),
ListIndicesError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListIndicesError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
AccessDenied(String),
InternalServer(String),
ResourceUnavailable(String),
Throttling(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListTagsForResourceError::AccessDenied(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(ListTagsForResourceError::InternalServer(err.msg))
}
"ResourceUnavailableException" => {
return RusotoError::Service(ListTagsForResourceError::ResourceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(ListTagsForResourceError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsForResourceError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InternalServer(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::ResourceUnavailable(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum ListThesauriError {
AccessDenied(String),
InternalServer(String),
ResourceNotFound(String),
Throttling(String),
}
impl ListThesauriError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListThesauriError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListThesauriError::AccessDenied(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(ListThesauriError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListThesauriError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(ListThesauriError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListThesauriError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListThesauriError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListThesauriError::InternalServer(ref cause) => write!(f, "{}", cause),
ListThesauriError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListThesauriError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListThesauriError {}
#[derive(Debug, PartialEq)]
pub enum QueryError {
AccessDenied(String),
Conflict(String),
InternalServer(String),
ResourceNotFound(String),
ServiceQuotaExceeded(String),
Throttling(String),
}
impl QueryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<QueryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(QueryError::AccessDenied(err.msg))
}
"ConflictException" => return RusotoError::Service(QueryError::Conflict(err.msg)),
"InternalServerException" => {
return RusotoError::Service(QueryError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(QueryError::ResourceNotFound(err.msg))
}
"ServiceQuotaExceededException" => {
return RusotoError::Service(QueryError::ServiceQuotaExceeded(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(QueryError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for QueryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
QueryError::AccessDenied(ref cause) => write!(f, "{}", cause),
QueryError::Conflict(ref cause) => write!(f, "{}", cause),
QueryError::InternalServer(ref cause) => write!(f, "{}", cause),
QueryError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
QueryError::ServiceQuotaExceeded(ref cause) => write!(f, "{}", cause),
QueryError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for QueryError {}
#[derive(Debug, PartialEq)]
pub enum StartDataSourceSyncJobError {
AccessDenied(String),
Conflict(String),
InternalServer(String),
ResourceInUse(String),
ResourceNotFound(String),
Throttling(String),
}
impl StartDataSourceSyncJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartDataSourceSyncJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(StartDataSourceSyncJobError::AccessDenied(err.msg))
}
"ConflictException" => {
return RusotoError::Service(StartDataSourceSyncJobError::Conflict(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(StartDataSourceSyncJobError::InternalServer(
err.msg,
))
}
"ResourceInUseException" => {
return RusotoError::Service(StartDataSourceSyncJobError::ResourceInUse(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(StartDataSourceSyncJobError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(StartDataSourceSyncJobError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartDataSourceSyncJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartDataSourceSyncJobError::AccessDenied(ref cause) => write!(f, "{}", cause),
StartDataSourceSyncJobError::Conflict(ref cause) => write!(f, "{}", cause),
StartDataSourceSyncJobError::InternalServer(ref cause) => write!(f, "{}", cause),
StartDataSourceSyncJobError::ResourceInUse(ref cause) => write!(f, "{}", cause),
StartDataSourceSyncJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
StartDataSourceSyncJobError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartDataSourceSyncJobError {}
#[derive(Debug, PartialEq)]
pub enum StopDataSourceSyncJobError {
AccessDenied(String),
InternalServer(String),
ResourceNotFound(String),
Throttling(String),
}
impl StopDataSourceSyncJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopDataSourceSyncJobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(StopDataSourceSyncJobError::AccessDenied(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(StopDataSourceSyncJobError::InternalServer(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(StopDataSourceSyncJobError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(StopDataSourceSyncJobError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StopDataSourceSyncJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StopDataSourceSyncJobError::AccessDenied(ref cause) => write!(f, "{}", cause),
StopDataSourceSyncJobError::InternalServer(ref cause) => write!(f, "{}", cause),
StopDataSourceSyncJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
StopDataSourceSyncJobError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StopDataSourceSyncJobError {}
#[derive(Debug, PartialEq)]
pub enum SubmitFeedbackError {
AccessDenied(String),
InternalServer(String),
ResourceNotFound(String),
ResourceUnavailable(String),
Throttling(String),
}
impl SubmitFeedbackError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SubmitFeedbackError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(SubmitFeedbackError::AccessDenied(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(SubmitFeedbackError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(SubmitFeedbackError::ResourceNotFound(err.msg))
}
"ResourceUnavailableException" => {
return RusotoError::Service(SubmitFeedbackError::ResourceUnavailable(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(SubmitFeedbackError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SubmitFeedbackError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SubmitFeedbackError::AccessDenied(ref cause) => write!(f, "{}", cause),
SubmitFeedbackError::InternalServer(ref cause) => write!(f, "{}", cause),
SubmitFeedbackError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
SubmitFeedbackError::ResourceUnavailable(ref cause) => write!(f, "{}", cause),
SubmitFeedbackError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SubmitFeedbackError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
AccessDenied(String),
InternalServer(String),
ResourceUnavailable(String),
Throttling(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(TagResourceError::AccessDenied(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(TagResourceError::InternalServer(err.msg))
}
"ResourceUnavailableException" => {
return RusotoError::Service(TagResourceError::ResourceUnavailable(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(TagResourceError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagResourceError::AccessDenied(ref cause) => write!(f, "{}", cause),
TagResourceError::InternalServer(ref cause) => write!(f, "{}", cause),
TagResourceError::ResourceUnavailable(ref cause) => write!(f, "{}", cause),
TagResourceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
AccessDenied(String),
InternalServer(String),
ResourceUnavailable(String),
Throttling(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(UntagResourceError::AccessDenied(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(UntagResourceError::InternalServer(err.msg))
}
"ResourceUnavailableException" => {
return RusotoError::Service(UntagResourceError::ResourceUnavailable(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(UntagResourceError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UntagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UntagResourceError::AccessDenied(ref cause) => write!(f, "{}", cause),
UntagResourceError::InternalServer(ref cause) => write!(f, "{}", cause),
UntagResourceError::ResourceUnavailable(ref cause) => write!(f, "{}", cause),
UntagResourceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateDataSourceError {
AccessDenied(String),
Conflict(String),
InternalServer(String),
ResourceNotFound(String),
Throttling(String),
}
impl UpdateDataSourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateDataSourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(UpdateDataSourceError::AccessDenied(err.msg))
}
"ConflictException" => {
return RusotoError::Service(UpdateDataSourceError::Conflict(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(UpdateDataSourceError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateDataSourceError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(UpdateDataSourceError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateDataSourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateDataSourceError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpdateDataSourceError::Conflict(ref cause) => write!(f, "{}", cause),
UpdateDataSourceError::InternalServer(ref cause) => write!(f, "{}", cause),
UpdateDataSourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateDataSourceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateDataSourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateIndexError {
AccessDenied(String),
Conflict(String),
InternalServer(String),
ResourceNotFound(String),
ServiceQuotaExceeded(String),
Throttling(String),
}
impl UpdateIndexError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateIndexError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(UpdateIndexError::AccessDenied(err.msg))
}
"ConflictException" => {
return RusotoError::Service(UpdateIndexError::Conflict(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(UpdateIndexError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateIndexError::ResourceNotFound(err.msg))
}
"ServiceQuotaExceededException" => {
return RusotoError::Service(UpdateIndexError::ServiceQuotaExceeded(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(UpdateIndexError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateIndexError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateIndexError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpdateIndexError::Conflict(ref cause) => write!(f, "{}", cause),
UpdateIndexError::InternalServer(ref cause) => write!(f, "{}", cause),
UpdateIndexError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateIndexError::ServiceQuotaExceeded(ref cause) => write!(f, "{}", cause),
UpdateIndexError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateIndexError {}
#[derive(Debug, PartialEq)]
pub enum UpdateThesaurusError {
AccessDenied(String),
Conflict(String),
InternalServer(String),
ResourceNotFound(String),
Throttling(String),
}
impl UpdateThesaurusError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateThesaurusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(UpdateThesaurusError::AccessDenied(err.msg))
}
"ConflictException" => {
return RusotoError::Service(UpdateThesaurusError::Conflict(err.msg))
}
"InternalServerException" => {
return RusotoError::Service(UpdateThesaurusError::InternalServer(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateThesaurusError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(UpdateThesaurusError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateThesaurusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateThesaurusError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpdateThesaurusError::Conflict(ref cause) => write!(f, "{}", cause),
UpdateThesaurusError::InternalServer(ref cause) => write!(f, "{}", cause),
UpdateThesaurusError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateThesaurusError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateThesaurusError {}
#[async_trait]
pub trait Kendra {
async fn batch_delete_document(
&self,
input: BatchDeleteDocumentRequest,
) -> Result<BatchDeleteDocumentResponse, RusotoError<BatchDeleteDocumentError>>;
async fn batch_put_document(
&self,
input: BatchPutDocumentRequest,
) -> Result<BatchPutDocumentResponse, RusotoError<BatchPutDocumentError>>;
async fn create_data_source(
&self,
input: CreateDataSourceRequest,
) -> Result<CreateDataSourceResponse, RusotoError<CreateDataSourceError>>;
async fn create_faq(
&self,
input: CreateFaqRequest,
) -> Result<CreateFaqResponse, RusotoError<CreateFaqError>>;
async fn create_index(
&self,
input: CreateIndexRequest,
) -> Result<CreateIndexResponse, RusotoError<CreateIndexError>>;
async fn create_thesaurus(
&self,
input: CreateThesaurusRequest,
) -> Result<CreateThesaurusResponse, RusotoError<CreateThesaurusError>>;
async fn delete_data_source(
&self,
input: DeleteDataSourceRequest,
) -> Result<(), RusotoError<DeleteDataSourceError>>;
async fn delete_faq(&self, input: DeleteFaqRequest) -> Result<(), RusotoError<DeleteFaqError>>;
async fn delete_index(
&self,
input: DeleteIndexRequest,
) -> Result<(), RusotoError<DeleteIndexError>>;
async fn delete_thesaurus(
&self,
input: DeleteThesaurusRequest,
) -> Result<(), RusotoError<DeleteThesaurusError>>;
async fn describe_data_source(
&self,
input: DescribeDataSourceRequest,
) -> Result<DescribeDataSourceResponse, RusotoError<DescribeDataSourceError>>;
async fn describe_faq(
&self,
input: DescribeFaqRequest,
) -> Result<DescribeFaqResponse, RusotoError<DescribeFaqError>>;
async fn describe_index(
&self,
input: DescribeIndexRequest,
) -> Result<DescribeIndexResponse, RusotoError<DescribeIndexError>>;
async fn describe_thesaurus(
&self,
input: DescribeThesaurusRequest,
) -> Result<DescribeThesaurusResponse, RusotoError<DescribeThesaurusError>>;
async fn list_data_source_sync_jobs(
&self,
input: ListDataSourceSyncJobsRequest,
) -> Result<ListDataSourceSyncJobsResponse, RusotoError<ListDataSourceSyncJobsError>>;
async fn list_data_sources(
&self,
input: ListDataSourcesRequest,
) -> Result<ListDataSourcesResponse, RusotoError<ListDataSourcesError>>;
async fn list_faqs(
&self,
input: ListFaqsRequest,
) -> Result<ListFaqsResponse, RusotoError<ListFaqsError>>;
async fn list_indices(
&self,
input: ListIndicesRequest,
) -> Result<ListIndicesResponse, RusotoError<ListIndicesError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
async fn list_thesauri(
&self,
input: ListThesauriRequest,
) -> Result<ListThesauriResponse, RusotoError<ListThesauriError>>;
async fn query(&self, input: QueryRequest) -> Result<QueryResult, RusotoError<QueryError>>;
async fn start_data_source_sync_job(
&self,
input: StartDataSourceSyncJobRequest,
) -> Result<StartDataSourceSyncJobResponse, RusotoError<StartDataSourceSyncJobError>>;
async fn stop_data_source_sync_job(
&self,
input: StopDataSourceSyncJobRequest,
) -> Result<(), RusotoError<StopDataSourceSyncJobError>>;
async fn submit_feedback(
&self,
input: SubmitFeedbackRequest,
) -> Result<(), RusotoError<SubmitFeedbackError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>>;
async fn update_data_source(
&self,
input: UpdateDataSourceRequest,
) -> Result<(), RusotoError<UpdateDataSourceError>>;
async fn update_index(
&self,
input: UpdateIndexRequest,
) -> Result<(), RusotoError<UpdateIndexError>>;
async fn update_thesaurus(
&self,
input: UpdateThesaurusRequest,
) -> Result<(), RusotoError<UpdateThesaurusError>>;
}
#[derive(Clone)]
pub struct KendraClient {
client: Client,
region: region::Region,
}
impl KendraClient {
pub fn new(region: region::Region) -> KendraClient {
KendraClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> KendraClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
KendraClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> KendraClient {
KendraClient { client, region }
}
}
#[async_trait]
impl Kendra for KendraClient {
async fn batch_delete_document(
&self,
input: BatchDeleteDocumentRequest,
) -> Result<BatchDeleteDocumentResponse, RusotoError<BatchDeleteDocumentError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSKendraFrontendService.BatchDeleteDocument",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, BatchDeleteDocumentError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<BatchDeleteDocumentResponse, _>()
}
async fn batch_put_document(
&self,
input: BatchPutDocumentRequest,
) -> Result<BatchPutDocumentResponse, RusotoError<BatchPutDocumentError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSKendraFrontendService.BatchPutDocument");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, BatchPutDocumentError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<BatchPutDocumentResponse, _>()
}
async fn create_data_source(
&self,
input: CreateDataSourceRequest,
) -> Result<CreateDataSourceResponse, RusotoError<CreateDataSourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSKendraFrontendService.CreateDataSource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateDataSourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateDataSourceResponse, _>()
}
async fn create_faq(
&self,
input: CreateFaqRequest,
) -> Result<CreateFaqResponse, RusotoError<CreateFaqError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSKendraFrontendService.CreateFaq");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateFaqError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateFaqResponse, _>()
}
async fn create_index(
&self,
input: CreateIndexRequest,
) -> Result<CreateIndexResponse, RusotoError<CreateIndexError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSKendraFrontendService.CreateIndex");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateIndexError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateIndexResponse, _>()
}
async fn create_thesaurus(
&self,
input: CreateThesaurusRequest,
) -> Result<CreateThesaurusResponse, RusotoError<CreateThesaurusError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSKendraFrontendService.CreateThesaurus");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateThesaurusError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateThesaurusResponse, _>()
}
async fn delete_data_source(
&self,
input: DeleteDataSourceRequest,
) -> Result<(), RusotoError<DeleteDataSourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSKendraFrontendService.DeleteDataSource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteDataSourceError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_faq(&self, input: DeleteFaqRequest) -> Result<(), RusotoError<DeleteFaqError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSKendraFrontendService.DeleteFaq");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteFaqError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_index(
&self,
input: DeleteIndexRequest,
) -> Result<(), RusotoError<DeleteIndexError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSKendraFrontendService.DeleteIndex");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteIndexError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_thesaurus(
&self,
input: DeleteThesaurusRequest,
) -> Result<(), RusotoError<DeleteThesaurusError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSKendraFrontendService.DeleteThesaurus");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteThesaurusError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn describe_data_source(
&self,
input: DescribeDataSourceRequest,
) -> Result<DescribeDataSourceResponse, RusotoError<DescribeDataSourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSKendraFrontendService.DescribeDataSource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeDataSourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeDataSourceResponse, _>()
}
async fn describe_faq(
&self,
input: DescribeFaqRequest,
) -> Result<DescribeFaqResponse, RusotoError<DescribeFaqError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSKendraFrontendService.DescribeFaq");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeFaqError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeFaqResponse, _>()
}
async fn describe_index(
&self,
input: DescribeIndexRequest,
) -> Result<DescribeIndexResponse, RusotoError<DescribeIndexError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSKendraFrontendService.DescribeIndex");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeIndexError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeIndexResponse, _>()
}
async fn describe_thesaurus(
&self,
input: DescribeThesaurusRequest,
) -> Result<DescribeThesaurusResponse, RusotoError<DescribeThesaurusError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSKendraFrontendService.DescribeThesaurus");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeThesaurusError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeThesaurusResponse, _>()
}
async fn list_data_source_sync_jobs(
&self,
input: ListDataSourceSyncJobsRequest,
) -> Result<ListDataSourceSyncJobsResponse, RusotoError<ListDataSourceSyncJobsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSKendraFrontendService.ListDataSourceSyncJobs",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListDataSourceSyncJobsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListDataSourceSyncJobsResponse, _>()
}
async fn list_data_sources(
&self,
input: ListDataSourcesRequest,
) -> Result<ListDataSourcesResponse, RusotoError<ListDataSourcesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSKendraFrontendService.ListDataSources");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListDataSourcesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListDataSourcesResponse, _>()
}
async fn list_faqs(
&self,
input: ListFaqsRequest,
) -> Result<ListFaqsResponse, RusotoError<ListFaqsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSKendraFrontendService.ListFaqs");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListFaqsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListFaqsResponse, _>()
}
async fn list_indices(
&self,
input: ListIndicesRequest,
) -> Result<ListIndicesResponse, RusotoError<ListIndicesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSKendraFrontendService.ListIndices");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListIndicesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListIndicesResponse, _>()
}
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSKendraFrontendService.ListTagsForResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListTagsForResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListTagsForResourceResponse, _>()
}
async fn list_thesauri(
&self,
input: ListThesauriRequest,
) -> Result<ListThesauriResponse, RusotoError<ListThesauriError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSKendraFrontendService.ListThesauri");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListThesauriError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListThesauriResponse, _>()
}
async fn query(&self, input: QueryRequest) -> Result<QueryResult, RusotoError<QueryError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSKendraFrontendService.Query");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, QueryError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<QueryResult, _>()
}
async fn start_data_source_sync_job(
&self,
input: StartDataSourceSyncJobRequest,
) -> Result<StartDataSourceSyncJobResponse, RusotoError<StartDataSourceSyncJobError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSKendraFrontendService.StartDataSourceSyncJob",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StartDataSourceSyncJobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<StartDataSourceSyncJobResponse, _>()
}
async fn stop_data_source_sync_job(
&self,
input: StopDataSourceSyncJobRequest,
) -> Result<(), RusotoError<StopDataSourceSyncJobError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSKendraFrontendService.StopDataSourceSyncJob",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StopDataSourceSyncJobError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn submit_feedback(
&self,
input: SubmitFeedbackRequest,
) -> Result<(), RusotoError<SubmitFeedbackError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSKendraFrontendService.SubmitFeedback");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, SubmitFeedbackError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSKendraFrontendService.TagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, TagResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<TagResourceResponse, _>()
}
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSKendraFrontendService.UntagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UntagResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UntagResourceResponse, _>()
}
async fn update_data_source(
&self,
input: UpdateDataSourceRequest,
) -> Result<(), RusotoError<UpdateDataSourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSKendraFrontendService.UpdateDataSource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateDataSourceError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn update_index(
&self,
input: UpdateIndexRequest,
) -> Result<(), RusotoError<UpdateIndexError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSKendraFrontendService.UpdateIndex");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateIndexError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn update_thesaurus(
&self,
input: UpdateThesaurusRequest,
) -> Result<(), RusotoError<UpdateThesaurusError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSKendraFrontendService.UpdateThesaurus");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateThesaurusError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
}