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::param::{Params, ServiceParams};
use rusoto_core::proto;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
use serde_json;
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AcceptInboundCrossClusterSearchConnectionRequest {
#[serde(rename = "CrossClusterSearchConnectionId")]
pub cross_cluster_search_connection_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AcceptInboundCrossClusterSearchConnectionResponse {
#[serde(rename = "CrossClusterSearchConnection")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cross_cluster_search_connection: Option<InboundCrossClusterSearchConnection>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AccessPoliciesStatus {
#[serde(rename = "Options")]
pub options: String,
#[serde(rename = "Status")]
pub status: OptionStatus,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AddTagsRequest {
#[serde(rename = "ARN")]
pub arn: String,
#[serde(rename = "TagList")]
pub tag_list: Vec<Tag>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdditionalLimit {
#[serde(rename = "LimitName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit_name: Option<String>,
#[serde(rename = "LimitValues")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit_values: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdvancedOptionsStatus {
#[serde(rename = "Options")]
pub options: ::std::collections::HashMap<String, String>,
#[serde(rename = "Status")]
pub status: OptionStatus,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdvancedSecurityOptions {
#[serde(rename = "Enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(rename = "InternalUserDatabaseEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub internal_user_database_enabled: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AdvancedSecurityOptionsInput {
#[serde(rename = "Enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(rename = "InternalUserDatabaseEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub internal_user_database_enabled: Option<bool>,
#[serde(rename = "MasterUserOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub master_user_options: Option<MasterUserOptions>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdvancedSecurityOptionsStatus {
#[serde(rename = "Options")]
pub options: AdvancedSecurityOptions,
#[serde(rename = "Status")]
pub status: OptionStatus,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AssociatePackageRequest {
#[serde(rename = "DomainName")]
pub domain_name: String,
#[serde(rename = "PackageID")]
pub package_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssociatePackageResponse {
#[serde(rename = "DomainPackageDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_package_details: Option<DomainPackageDetails>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CancelElasticsearchServiceSoftwareUpdateRequest {
#[serde(rename = "DomainName")]
pub domain_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CancelElasticsearchServiceSoftwareUpdateResponse {
#[serde(rename = "ServiceSoftwareOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_software_options: Option<ServiceSoftwareOptions>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CognitoOptions {
#[serde(rename = "Enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(rename = "IdentityPoolId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_pool_id: Option<String>,
#[serde(rename = "RoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
#[serde(rename = "UserPoolId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_pool_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CognitoOptionsStatus {
#[serde(rename = "Options")]
pub options: CognitoOptions,
#[serde(rename = "Status")]
pub status: OptionStatus,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CompatibleVersionsMap {
#[serde(rename = "SourceVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_version: Option<String>,
#[serde(rename = "TargetVersions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_versions: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateElasticsearchDomainRequest {
#[serde(rename = "AccessPolicies")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_policies: Option<String>,
#[serde(rename = "AdvancedOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub advanced_options: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "AdvancedSecurityOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub advanced_security_options: Option<AdvancedSecurityOptionsInput>,
#[serde(rename = "CognitoOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cognito_options: Option<CognitoOptions>,
#[serde(rename = "DomainEndpointOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_endpoint_options: Option<DomainEndpointOptions>,
#[serde(rename = "DomainName")]
pub domain_name: String,
#[serde(rename = "EBSOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ebs_options: Option<EBSOptions>,
#[serde(rename = "ElasticsearchClusterConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub elasticsearch_cluster_config: Option<ElasticsearchClusterConfig>,
#[serde(rename = "ElasticsearchVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub elasticsearch_version: Option<String>,
#[serde(rename = "EncryptionAtRestOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encryption_at_rest_options: Option<EncryptionAtRestOptions>,
#[serde(rename = "LogPublishingOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_publishing_options: Option<::std::collections::HashMap<String, LogPublishingOption>>,
#[serde(rename = "NodeToNodeEncryptionOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub node_to_node_encryption_options: Option<NodeToNodeEncryptionOptions>,
#[serde(rename = "SnapshotOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snapshot_options: Option<SnapshotOptions>,
#[serde(rename = "VPCOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_options: Option<VPCOptions>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateElasticsearchDomainResponse {
#[serde(rename = "DomainStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_status: Option<ElasticsearchDomainStatus>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateOutboundCrossClusterSearchConnectionRequest {
#[serde(rename = "ConnectionAlias")]
pub connection_alias: String,
#[serde(rename = "DestinationDomainInfo")]
pub destination_domain_info: DomainInformation,
#[serde(rename = "SourceDomainInfo")]
pub source_domain_info: DomainInformation,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateOutboundCrossClusterSearchConnectionResponse {
#[serde(rename = "ConnectionAlias")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_alias: Option<String>,
#[serde(rename = "ConnectionStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_status: Option<OutboundCrossClusterSearchConnectionStatus>,
#[serde(rename = "CrossClusterSearchConnectionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cross_cluster_search_connection_id: Option<String>,
#[serde(rename = "DestinationDomainInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_domain_info: Option<DomainInformation>,
#[serde(rename = "SourceDomainInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_domain_info: Option<DomainInformation>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreatePackageRequest {
#[serde(rename = "PackageDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub package_description: Option<String>,
#[serde(rename = "PackageName")]
pub package_name: String,
#[serde(rename = "PackageSource")]
pub package_source: PackageSource,
#[serde(rename = "PackageType")]
pub package_type: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreatePackageResponse {
#[serde(rename = "PackageDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub package_details: Option<PackageDetails>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteElasticsearchDomainRequest {
#[serde(rename = "DomainName")]
pub domain_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteElasticsearchDomainResponse {
#[serde(rename = "DomainStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_status: Option<ElasticsearchDomainStatus>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteInboundCrossClusterSearchConnectionRequest {
#[serde(rename = "CrossClusterSearchConnectionId")]
pub cross_cluster_search_connection_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteInboundCrossClusterSearchConnectionResponse {
#[serde(rename = "CrossClusterSearchConnection")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cross_cluster_search_connection: Option<InboundCrossClusterSearchConnection>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteOutboundCrossClusterSearchConnectionRequest {
#[serde(rename = "CrossClusterSearchConnectionId")]
pub cross_cluster_search_connection_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteOutboundCrossClusterSearchConnectionResponse {
#[serde(rename = "CrossClusterSearchConnection")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cross_cluster_search_connection: Option<OutboundCrossClusterSearchConnection>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeletePackageRequest {
#[serde(rename = "PackageID")]
pub package_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeletePackageResponse {
#[serde(rename = "PackageDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub package_details: Option<PackageDetails>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeElasticsearchDomainConfigRequest {
#[serde(rename = "DomainName")]
pub domain_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeElasticsearchDomainConfigResponse {
#[serde(rename = "DomainConfig")]
pub domain_config: ElasticsearchDomainConfig,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeElasticsearchDomainRequest {
#[serde(rename = "DomainName")]
pub domain_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeElasticsearchDomainResponse {
#[serde(rename = "DomainStatus")]
pub domain_status: ElasticsearchDomainStatus,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeElasticsearchDomainsRequest {
#[serde(rename = "DomainNames")]
pub domain_names: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeElasticsearchDomainsResponse {
#[serde(rename = "DomainStatusList")]
pub domain_status_list: Vec<ElasticsearchDomainStatus>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeElasticsearchInstanceTypeLimitsRequest {
#[serde(rename = "DomainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name: Option<String>,
#[serde(rename = "ElasticsearchVersion")]
pub elasticsearch_version: String,
#[serde(rename = "InstanceType")]
pub instance_type: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeElasticsearchInstanceTypeLimitsResponse {
#[serde(rename = "LimitsByRole")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limits_by_role: Option<::std::collections::HashMap<String, Limits>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeInboundCrossClusterSearchConnectionsRequest {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[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 DescribeInboundCrossClusterSearchConnectionsResponse {
#[serde(rename = "CrossClusterSearchConnections")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cross_cluster_search_connections: Option<Vec<InboundCrossClusterSearchConnection>>,
#[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 DescribeOutboundCrossClusterSearchConnectionsRequest {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[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 DescribeOutboundCrossClusterSearchConnectionsResponse {
#[serde(rename = "CrossClusterSearchConnections")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cross_cluster_search_connections: Option<Vec<OutboundCrossClusterSearchConnection>>,
#[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 DescribePackagesFilter {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribePackagesRequest {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<DescribePackagesFilter>>,
#[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 DescribePackagesResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "PackageDetailsList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub package_details_list: Option<Vec<PackageDetails>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeReservedElasticsearchInstanceOfferingsRequest {
#[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 = "ReservedElasticsearchInstanceOfferingId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reserved_elasticsearch_instance_offering_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeReservedElasticsearchInstanceOfferingsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ReservedElasticsearchInstanceOfferings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reserved_elasticsearch_instance_offerings:
Option<Vec<ReservedElasticsearchInstanceOffering>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeReservedElasticsearchInstancesRequest {
#[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 = "ReservedElasticsearchInstanceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reserved_elasticsearch_instance_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeReservedElasticsearchInstancesResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ReservedElasticsearchInstances")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reserved_elasticsearch_instances: Option<Vec<ReservedElasticsearchInstance>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DissociatePackageRequest {
#[serde(rename = "DomainName")]
pub domain_name: String,
#[serde(rename = "PackageID")]
pub package_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DissociatePackageResponse {
#[serde(rename = "DomainPackageDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_package_details: Option<DomainPackageDetails>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DomainEndpointOptions {
#[serde(rename = "EnforceHTTPS")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enforce_https: Option<bool>,
#[serde(rename = "TLSSecurityPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tls_security_policy: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DomainEndpointOptionsStatus {
#[serde(rename = "Options")]
pub options: DomainEndpointOptions,
#[serde(rename = "Status")]
pub status: OptionStatus,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DomainInfo {
#[serde(rename = "DomainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DomainInformation {
#[serde(rename = "DomainName")]
pub domain_name: String,
#[serde(rename = "OwnerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner_id: Option<String>,
#[serde(rename = "Region")]
#[serde(skip_serializing_if = "Option::is_none")]
pub region: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DomainPackageDetails {
#[serde(rename = "DomainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name: Option<String>,
#[serde(rename = "DomainPackageStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_package_status: Option<String>,
#[serde(rename = "ErrorDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_details: Option<ErrorDetails>,
#[serde(rename = "LastUpdated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated: Option<f64>,
#[serde(rename = "PackageID")]
#[serde(skip_serializing_if = "Option::is_none")]
pub package_id: Option<String>,
#[serde(rename = "PackageName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub package_name: Option<String>,
#[serde(rename = "PackageType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub package_type: Option<String>,
#[serde(rename = "ReferencePath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reference_path: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct EBSOptions {
#[serde(rename = "EBSEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ebs_enabled: Option<bool>,
#[serde(rename = "Iops")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iops: Option<i64>,
#[serde(rename = "VolumeSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_size: Option<i64>,
#[serde(rename = "VolumeType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EBSOptionsStatus {
#[serde(rename = "Options")]
pub options: EBSOptions,
#[serde(rename = "Status")]
pub status: OptionStatus,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ElasticsearchClusterConfig {
#[serde(rename = "DedicatedMasterCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dedicated_master_count: Option<i64>,
#[serde(rename = "DedicatedMasterEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dedicated_master_enabled: Option<bool>,
#[serde(rename = "DedicatedMasterType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dedicated_master_type: Option<String>,
#[serde(rename = "InstanceCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_count: Option<i64>,
#[serde(rename = "InstanceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_type: Option<String>,
#[serde(rename = "WarmCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub warm_count: Option<i64>,
#[serde(rename = "WarmEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub warm_enabled: Option<bool>,
#[serde(rename = "WarmType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub warm_type: Option<String>,
#[serde(rename = "ZoneAwarenessConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub zone_awareness_config: Option<ZoneAwarenessConfig>,
#[serde(rename = "ZoneAwarenessEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub zone_awareness_enabled: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ElasticsearchClusterConfigStatus {
#[serde(rename = "Options")]
pub options: ElasticsearchClusterConfig,
#[serde(rename = "Status")]
pub status: OptionStatus,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ElasticsearchDomainConfig {
#[serde(rename = "AccessPolicies")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_policies: Option<AccessPoliciesStatus>,
#[serde(rename = "AdvancedOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub advanced_options: Option<AdvancedOptionsStatus>,
#[serde(rename = "AdvancedSecurityOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub advanced_security_options: Option<AdvancedSecurityOptionsStatus>,
#[serde(rename = "CognitoOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cognito_options: Option<CognitoOptionsStatus>,
#[serde(rename = "DomainEndpointOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_endpoint_options: Option<DomainEndpointOptionsStatus>,
#[serde(rename = "EBSOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ebs_options: Option<EBSOptionsStatus>,
#[serde(rename = "ElasticsearchClusterConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub elasticsearch_cluster_config: Option<ElasticsearchClusterConfigStatus>,
#[serde(rename = "ElasticsearchVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub elasticsearch_version: Option<ElasticsearchVersionStatus>,
#[serde(rename = "EncryptionAtRestOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encryption_at_rest_options: Option<EncryptionAtRestOptionsStatus>,
#[serde(rename = "LogPublishingOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_publishing_options: Option<LogPublishingOptionsStatus>,
#[serde(rename = "NodeToNodeEncryptionOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub node_to_node_encryption_options: Option<NodeToNodeEncryptionOptionsStatus>,
#[serde(rename = "SnapshotOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snapshot_options: Option<SnapshotOptionsStatus>,
#[serde(rename = "VPCOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_options: Option<VPCDerivedInfoStatus>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ElasticsearchDomainStatus {
#[serde(rename = "ARN")]
pub arn: String,
#[serde(rename = "AccessPolicies")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_policies: Option<String>,
#[serde(rename = "AdvancedOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub advanced_options: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "AdvancedSecurityOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub advanced_security_options: Option<AdvancedSecurityOptions>,
#[serde(rename = "CognitoOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cognito_options: Option<CognitoOptions>,
#[serde(rename = "Created")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created: Option<bool>,
#[serde(rename = "Deleted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deleted: Option<bool>,
#[serde(rename = "DomainEndpointOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_endpoint_options: Option<DomainEndpointOptions>,
#[serde(rename = "DomainId")]
pub domain_id: String,
#[serde(rename = "DomainName")]
pub domain_name: String,
#[serde(rename = "EBSOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ebs_options: Option<EBSOptions>,
#[serde(rename = "ElasticsearchClusterConfig")]
pub elasticsearch_cluster_config: ElasticsearchClusterConfig,
#[serde(rename = "ElasticsearchVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub elasticsearch_version: Option<String>,
#[serde(rename = "EncryptionAtRestOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encryption_at_rest_options: Option<EncryptionAtRestOptions>,
#[serde(rename = "Endpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint: Option<String>,
#[serde(rename = "Endpoints")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoints: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "LogPublishingOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_publishing_options: Option<::std::collections::HashMap<String, LogPublishingOption>>,
#[serde(rename = "NodeToNodeEncryptionOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub node_to_node_encryption_options: Option<NodeToNodeEncryptionOptions>,
#[serde(rename = "Processing")]
#[serde(skip_serializing_if = "Option::is_none")]
pub processing: Option<bool>,
#[serde(rename = "ServiceSoftwareOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_software_options: Option<ServiceSoftwareOptions>,
#[serde(rename = "SnapshotOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snapshot_options: Option<SnapshotOptions>,
#[serde(rename = "UpgradeProcessing")]
#[serde(skip_serializing_if = "Option::is_none")]
pub upgrade_processing: Option<bool>,
#[serde(rename = "VPCOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_options: Option<VPCDerivedInfo>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ElasticsearchVersionStatus {
#[serde(rename = "Options")]
pub options: String,
#[serde(rename = "Status")]
pub status: OptionStatus,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct EncryptionAtRestOptions {
#[serde(rename = "Enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(rename = "KmsKeyId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EncryptionAtRestOptionsStatus {
#[serde(rename = "Options")]
pub options: EncryptionAtRestOptions,
#[serde(rename = "Status")]
pub status: OptionStatus,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ErrorDetails {
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "ErrorType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_type: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Filter {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Values")]
#[serde(skip_serializing_if = "Option::is_none")]
pub values: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetCompatibleElasticsearchVersionsRequest {
#[serde(rename = "DomainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetCompatibleElasticsearchVersionsResponse {
#[serde(rename = "CompatibleElasticsearchVersions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compatible_elasticsearch_versions: Option<Vec<CompatibleVersionsMap>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetUpgradeHistoryRequest {
#[serde(rename = "DomainName")]
pub domain_name: 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 GetUpgradeHistoryResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "UpgradeHistories")]
#[serde(skip_serializing_if = "Option::is_none")]
pub upgrade_histories: Option<Vec<UpgradeHistory>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetUpgradeStatusRequest {
#[serde(rename = "DomainName")]
pub domain_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetUpgradeStatusResponse {
#[serde(rename = "StepStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub step_status: Option<String>,
#[serde(rename = "UpgradeName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub upgrade_name: Option<String>,
#[serde(rename = "UpgradeStep")]
#[serde(skip_serializing_if = "Option::is_none")]
pub upgrade_step: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InboundCrossClusterSearchConnection {
#[serde(rename = "ConnectionStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_status: Option<InboundCrossClusterSearchConnectionStatus>,
#[serde(rename = "CrossClusterSearchConnectionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cross_cluster_search_connection_id: Option<String>,
#[serde(rename = "DestinationDomainInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_domain_info: Option<DomainInformation>,
#[serde(rename = "SourceDomainInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_domain_info: Option<DomainInformation>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InboundCrossClusterSearchConnectionStatus {
#[serde(rename = "Message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(rename = "StatusCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_code: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InstanceCountLimits {
#[serde(rename = "MaximumInstanceCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum_instance_count: Option<i64>,
#[serde(rename = "MinimumInstanceCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub minimum_instance_count: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InstanceLimits {
#[serde(rename = "InstanceCountLimits")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_count_limits: Option<InstanceCountLimits>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Limits {
#[serde(rename = "AdditionalLimits")]
#[serde(skip_serializing_if = "Option::is_none")]
pub additional_limits: Option<Vec<AdditionalLimit>>,
#[serde(rename = "InstanceLimits")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_limits: Option<InstanceLimits>,
#[serde(rename = "StorageTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub storage_types: Option<Vec<StorageType>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDomainNamesResponse {
#[serde(rename = "DomainNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_names: Option<Vec<DomainInfo>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDomainsForPackageRequest {
#[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 = "PackageID")]
pub package_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDomainsForPackageResponse {
#[serde(rename = "DomainPackageDetailsList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_package_details_list: Option<Vec<DomainPackageDetails>>,
#[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 ListElasticsearchInstanceTypesRequest {
#[serde(rename = "DomainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name: Option<String>,
#[serde(rename = "ElasticsearchVersion")]
pub elasticsearch_version: 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 ListElasticsearchInstanceTypesResponse {
#[serde(rename = "ElasticsearchInstanceTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub elasticsearch_instance_types: Option<Vec<String>>,
#[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 ListElasticsearchVersionsRequest {
#[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 ListElasticsearchVersionsResponse {
#[serde(rename = "ElasticsearchVersions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub elasticsearch_versions: Option<Vec<String>>,
#[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 ListPackagesForDomainRequest {
#[serde(rename = "DomainName")]
pub domain_name: 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 ListPackagesForDomainResponse {
#[serde(rename = "DomainPackageDetailsList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_package_details_list: Option<Vec<DomainPackageDetails>>,
#[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 ListTagsRequest {
#[serde(rename = "ARN")]
pub arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsResponse {
#[serde(rename = "TagList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tag_list: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct LogPublishingOption {
#[serde(rename = "CloudWatchLogsLogGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_watch_logs_log_group_arn: Option<String>,
#[serde(rename = "Enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LogPublishingOptionsStatus {
#[serde(rename = "Options")]
#[serde(skip_serializing_if = "Option::is_none")]
pub options: Option<::std::collections::HashMap<String, LogPublishingOption>>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<OptionStatus>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct MasterUserOptions {
#[serde(rename = "MasterUserARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub master_user_arn: Option<String>,
#[serde(rename = "MasterUserName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub master_user_name: Option<String>,
#[serde(rename = "MasterUserPassword")]
#[serde(skip_serializing_if = "Option::is_none")]
pub master_user_password: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct NodeToNodeEncryptionOptions {
#[serde(rename = "Enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct NodeToNodeEncryptionOptionsStatus {
#[serde(rename = "Options")]
pub options: NodeToNodeEncryptionOptions,
#[serde(rename = "Status")]
pub status: OptionStatus,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct OptionStatus {
#[serde(rename = "CreationDate")]
pub creation_date: f64,
#[serde(rename = "PendingDeletion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pending_deletion: Option<bool>,
#[serde(rename = "State")]
pub state: String,
#[serde(rename = "UpdateDate")]
pub update_date: f64,
#[serde(rename = "UpdateVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub update_version: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct OutboundCrossClusterSearchConnection {
#[serde(rename = "ConnectionAlias")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_alias: Option<String>,
#[serde(rename = "ConnectionStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_status: Option<OutboundCrossClusterSearchConnectionStatus>,
#[serde(rename = "CrossClusterSearchConnectionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cross_cluster_search_connection_id: Option<String>,
#[serde(rename = "DestinationDomainInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_domain_info: Option<DomainInformation>,
#[serde(rename = "SourceDomainInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_domain_info: Option<DomainInformation>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct OutboundCrossClusterSearchConnectionStatus {
#[serde(rename = "Message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(rename = "StatusCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_code: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PackageDetails {
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "ErrorDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_details: Option<ErrorDetails>,
#[serde(rename = "PackageDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub package_description: Option<String>,
#[serde(rename = "PackageID")]
#[serde(skip_serializing_if = "Option::is_none")]
pub package_id: Option<String>,
#[serde(rename = "PackageName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub package_name: Option<String>,
#[serde(rename = "PackageStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub package_status: Option<String>,
#[serde(rename = "PackageType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub package_type: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PackageSource {
#[serde(rename = "S3BucketName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_bucket_name: Option<String>,
#[serde(rename = "S3Key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_key: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PurchaseReservedElasticsearchInstanceOfferingRequest {
#[serde(rename = "InstanceCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_count: Option<i64>,
#[serde(rename = "ReservationName")]
pub reservation_name: String,
#[serde(rename = "ReservedElasticsearchInstanceOfferingId")]
pub reserved_elasticsearch_instance_offering_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PurchaseReservedElasticsearchInstanceOfferingResponse {
#[serde(rename = "ReservationName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reservation_name: Option<String>,
#[serde(rename = "ReservedElasticsearchInstanceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reserved_elasticsearch_instance_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RecurringCharge {
#[serde(rename = "RecurringChargeAmount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recurring_charge_amount: Option<f64>,
#[serde(rename = "RecurringChargeFrequency")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recurring_charge_frequency: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RejectInboundCrossClusterSearchConnectionRequest {
#[serde(rename = "CrossClusterSearchConnectionId")]
pub cross_cluster_search_connection_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RejectInboundCrossClusterSearchConnectionResponse {
#[serde(rename = "CrossClusterSearchConnection")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cross_cluster_search_connection: Option<InboundCrossClusterSearchConnection>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RemoveTagsRequest {
#[serde(rename = "ARN")]
pub 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 ReservedElasticsearchInstance {
#[serde(rename = "CurrencyCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub currency_code: Option<String>,
#[serde(rename = "Duration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub duration: Option<i64>,
#[serde(rename = "ElasticsearchInstanceCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub elasticsearch_instance_count: Option<i64>,
#[serde(rename = "ElasticsearchInstanceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub elasticsearch_instance_type: Option<String>,
#[serde(rename = "FixedPrice")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fixed_price: Option<f64>,
#[serde(rename = "PaymentOption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_option: Option<String>,
#[serde(rename = "RecurringCharges")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recurring_charges: Option<Vec<RecurringCharge>>,
#[serde(rename = "ReservationName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reservation_name: Option<String>,
#[serde(rename = "ReservedElasticsearchInstanceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reserved_elasticsearch_instance_id: Option<String>,
#[serde(rename = "ReservedElasticsearchInstanceOfferingId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reserved_elasticsearch_instance_offering_id: Option<String>,
#[serde(rename = "StartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "UsagePrice")]
#[serde(skip_serializing_if = "Option::is_none")]
pub usage_price: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ReservedElasticsearchInstanceOffering {
#[serde(rename = "CurrencyCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub currency_code: Option<String>,
#[serde(rename = "Duration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub duration: Option<i64>,
#[serde(rename = "ElasticsearchInstanceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub elasticsearch_instance_type: Option<String>,
#[serde(rename = "FixedPrice")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fixed_price: Option<f64>,
#[serde(rename = "PaymentOption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub payment_option: Option<String>,
#[serde(rename = "RecurringCharges")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recurring_charges: Option<Vec<RecurringCharge>>,
#[serde(rename = "ReservedElasticsearchInstanceOfferingId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reserved_elasticsearch_instance_offering_id: Option<String>,
#[serde(rename = "UsagePrice")]
#[serde(skip_serializing_if = "Option::is_none")]
pub usage_price: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ServiceSoftwareOptions {
#[serde(rename = "AutomatedUpdateDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub automated_update_date: Option<f64>,
#[serde(rename = "Cancellable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cancellable: Option<bool>,
#[serde(rename = "CurrentVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub current_version: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "NewVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub new_version: Option<String>,
#[serde(rename = "OptionalDeployment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub optional_deployment: Option<bool>,
#[serde(rename = "UpdateAvailable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub update_available: Option<bool>,
#[serde(rename = "UpdateStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub update_status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SnapshotOptions {
#[serde(rename = "AutomatedSnapshotStartHour")]
#[serde(skip_serializing_if = "Option::is_none")]
pub automated_snapshot_start_hour: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SnapshotOptionsStatus {
#[serde(rename = "Options")]
pub options: SnapshotOptions,
#[serde(rename = "Status")]
pub status: OptionStatus,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartElasticsearchServiceSoftwareUpdateRequest {
#[serde(rename = "DomainName")]
pub domain_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartElasticsearchServiceSoftwareUpdateResponse {
#[serde(rename = "ServiceSoftwareOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_software_options: Option<ServiceSoftwareOptions>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StorageType {
#[serde(rename = "StorageSubTypeName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub storage_sub_type_name: Option<String>,
#[serde(rename = "StorageTypeLimits")]
#[serde(skip_serializing_if = "Option::is_none")]
pub storage_type_limits: Option<Vec<StorageTypeLimit>>,
#[serde(rename = "StorageTypeName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub storage_type_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StorageTypeLimit {
#[serde(rename = "LimitName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit_name: Option<String>,
#[serde(rename = "LimitValues")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit_values: Option<Vec<String>>,
}
#[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 UpdateElasticsearchDomainConfigRequest {
#[serde(rename = "AccessPolicies")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_policies: Option<String>,
#[serde(rename = "AdvancedOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub advanced_options: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "AdvancedSecurityOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub advanced_security_options: Option<AdvancedSecurityOptionsInput>,
#[serde(rename = "CognitoOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cognito_options: Option<CognitoOptions>,
#[serde(rename = "DomainEndpointOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_endpoint_options: Option<DomainEndpointOptions>,
#[serde(rename = "DomainName")]
pub domain_name: String,
#[serde(rename = "EBSOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ebs_options: Option<EBSOptions>,
#[serde(rename = "ElasticsearchClusterConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub elasticsearch_cluster_config: Option<ElasticsearchClusterConfig>,
#[serde(rename = "LogPublishingOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_publishing_options: Option<::std::collections::HashMap<String, LogPublishingOption>>,
#[serde(rename = "SnapshotOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snapshot_options: Option<SnapshotOptions>,
#[serde(rename = "VPCOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_options: Option<VPCOptions>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateElasticsearchDomainConfigResponse {
#[serde(rename = "DomainConfig")]
pub domain_config: ElasticsearchDomainConfig,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpgradeElasticsearchDomainRequest {
#[serde(rename = "DomainName")]
pub domain_name: String,
#[serde(rename = "PerformCheckOnly")]
#[serde(skip_serializing_if = "Option::is_none")]
pub perform_check_only: Option<bool>,
#[serde(rename = "TargetVersion")]
pub target_version: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpgradeElasticsearchDomainResponse {
#[serde(rename = "DomainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name: Option<String>,
#[serde(rename = "PerformCheckOnly")]
#[serde(skip_serializing_if = "Option::is_none")]
pub perform_check_only: Option<bool>,
#[serde(rename = "TargetVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpgradeHistory {
#[serde(rename = "StartTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_timestamp: Option<f64>,
#[serde(rename = "StepsList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub steps_list: Option<Vec<UpgradeStepItem>>,
#[serde(rename = "UpgradeName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub upgrade_name: Option<String>,
#[serde(rename = "UpgradeStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub upgrade_status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpgradeStepItem {
#[serde(rename = "Issues")]
#[serde(skip_serializing_if = "Option::is_none")]
pub issues: Option<Vec<String>>,
#[serde(rename = "ProgressPercent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub progress_percent: Option<f64>,
#[serde(rename = "UpgradeStep")]
#[serde(skip_serializing_if = "Option::is_none")]
pub upgrade_step: Option<String>,
#[serde(rename = "UpgradeStepStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub upgrade_step_status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct VPCDerivedInfo {
#[serde(rename = "AvailabilityZones")]
#[serde(skip_serializing_if = "Option::is_none")]
pub availability_zones: Option<Vec<String>>,
#[serde(rename = "SecurityGroupIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_group_ids: Option<Vec<String>>,
#[serde(rename = "SubnetIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_ids: Option<Vec<String>>,
#[serde(rename = "VPCId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct VPCDerivedInfoStatus {
#[serde(rename = "Options")]
pub options: VPCDerivedInfo,
#[serde(rename = "Status")]
pub status: OptionStatus,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct VPCOptions {
#[serde(rename = "SecurityGroupIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_group_ids: Option<Vec<String>>,
#[serde(rename = "SubnetIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_ids: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ZoneAwarenessConfig {
#[serde(rename = "AvailabilityZoneCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub availability_zone_count: Option<i64>,
}
#[derive(Debug, PartialEq)]
pub enum AcceptInboundCrossClusterSearchConnectionError {
DisabledOperation(String),
LimitExceeded(String),
ResourceNotFound(String),
}
impl AcceptInboundCrossClusterSearchConnectionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AcceptInboundCrossClusterSearchConnectionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DisabledOperationException" => {
return RusotoError::Service(
AcceptInboundCrossClusterSearchConnectionError::DisabledOperation(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(
AcceptInboundCrossClusterSearchConnectionError::LimitExceeded(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
AcceptInboundCrossClusterSearchConnectionError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AcceptInboundCrossClusterSearchConnectionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AcceptInboundCrossClusterSearchConnectionError::DisabledOperation(ref cause) => {
write!(f, "{}", cause)
}
AcceptInboundCrossClusterSearchConnectionError::LimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
AcceptInboundCrossClusterSearchConnectionError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AcceptInboundCrossClusterSearchConnectionError {}
#[derive(Debug, PartialEq)]
pub enum AddTagsError {
Base(String),
Internal(String),
LimitExceeded(String),
}
impl AddTagsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AddTagsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BaseException" => return RusotoError::Service(AddTagsError::Base(err.msg)),
"InternalException" => {
return RusotoError::Service(AddTagsError::Internal(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(AddTagsError::LimitExceeded(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AddTagsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AddTagsError::Base(ref cause) => write!(f, "{}", cause),
AddTagsError::Internal(ref cause) => write!(f, "{}", cause),
AddTagsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AddTagsError {}
#[derive(Debug, PartialEq)]
pub enum AssociatePackageError {
AccessDenied(String),
Base(String),
Conflict(String),
Internal(String),
ResourceNotFound(String),
}
impl AssociatePackageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AssociatePackageError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(AssociatePackageError::AccessDenied(err.msg))
}
"BaseException" => {
return RusotoError::Service(AssociatePackageError::Base(err.msg))
}
"ConflictException" => {
return RusotoError::Service(AssociatePackageError::Conflict(err.msg))
}
"InternalException" => {
return RusotoError::Service(AssociatePackageError::Internal(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AssociatePackageError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociatePackageError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociatePackageError::AccessDenied(ref cause) => write!(f, "{}", cause),
AssociatePackageError::Base(ref cause) => write!(f, "{}", cause),
AssociatePackageError::Conflict(ref cause) => write!(f, "{}", cause),
AssociatePackageError::Internal(ref cause) => write!(f, "{}", cause),
AssociatePackageError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AssociatePackageError {}
#[derive(Debug, PartialEq)]
pub enum CancelElasticsearchServiceSoftwareUpdateError {
Base(String),
Internal(String),
ResourceNotFound(String),
}
impl CancelElasticsearchServiceSoftwareUpdateError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CancelElasticsearchServiceSoftwareUpdateError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BaseException" => {
return RusotoError::Service(
CancelElasticsearchServiceSoftwareUpdateError::Base(err.msg),
)
}
"InternalException" => {
return RusotoError::Service(
CancelElasticsearchServiceSoftwareUpdateError::Internal(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
CancelElasticsearchServiceSoftwareUpdateError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CancelElasticsearchServiceSoftwareUpdateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CancelElasticsearchServiceSoftwareUpdateError::Base(ref cause) => {
write!(f, "{}", cause)
}
CancelElasticsearchServiceSoftwareUpdateError::Internal(ref cause) => {
write!(f, "{}", cause)
}
CancelElasticsearchServiceSoftwareUpdateError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CancelElasticsearchServiceSoftwareUpdateError {}
#[derive(Debug, PartialEq)]
pub enum CreateElasticsearchDomainError {
Base(String),
DisabledOperation(String),
Internal(String),
InvalidType(String),
LimitExceeded(String),
ResourceAlreadyExists(String),
}
impl CreateElasticsearchDomainError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateElasticsearchDomainError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BaseException" => {
return RusotoError::Service(CreateElasticsearchDomainError::Base(err.msg))
}
"DisabledOperationException" => {
return RusotoError::Service(CreateElasticsearchDomainError::DisabledOperation(
err.msg,
))
}
"InternalException" => {
return RusotoError::Service(CreateElasticsearchDomainError::Internal(err.msg))
}
"InvalidTypeException" => {
return RusotoError::Service(CreateElasticsearchDomainError::InvalidType(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(CreateElasticsearchDomainError::LimitExceeded(
err.msg,
))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(
CreateElasticsearchDomainError::ResourceAlreadyExists(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateElasticsearchDomainError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateElasticsearchDomainError::Base(ref cause) => write!(f, "{}", cause),
CreateElasticsearchDomainError::DisabledOperation(ref cause) => write!(f, "{}", cause),
CreateElasticsearchDomainError::Internal(ref cause) => write!(f, "{}", cause),
CreateElasticsearchDomainError::InvalidType(ref cause) => write!(f, "{}", cause),
CreateElasticsearchDomainError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateElasticsearchDomainError::ResourceAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateElasticsearchDomainError {}
#[derive(Debug, PartialEq)]
pub enum CreateOutboundCrossClusterSearchConnectionError {
DisabledOperation(String),
Internal(String),
LimitExceeded(String),
ResourceAlreadyExists(String),
}
impl CreateOutboundCrossClusterSearchConnectionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateOutboundCrossClusterSearchConnectionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DisabledOperationException" => {
return RusotoError::Service(
CreateOutboundCrossClusterSearchConnectionError::DisabledOperation(err.msg),
)
}
"InternalException" => {
return RusotoError::Service(
CreateOutboundCrossClusterSearchConnectionError::Internal(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(
CreateOutboundCrossClusterSearchConnectionError::LimitExceeded(err.msg),
)
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(
CreateOutboundCrossClusterSearchConnectionError::ResourceAlreadyExists(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateOutboundCrossClusterSearchConnectionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateOutboundCrossClusterSearchConnectionError::DisabledOperation(ref cause) => {
write!(f, "{}", cause)
}
CreateOutboundCrossClusterSearchConnectionError::Internal(ref cause) => {
write!(f, "{}", cause)
}
CreateOutboundCrossClusterSearchConnectionError::LimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
CreateOutboundCrossClusterSearchConnectionError::ResourceAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateOutboundCrossClusterSearchConnectionError {}
#[derive(Debug, PartialEq)]
pub enum CreatePackageError {
AccessDenied(String),
Base(String),
Internal(String),
InvalidType(String),
LimitExceeded(String),
ResourceAlreadyExists(String),
}
impl CreatePackageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreatePackageError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreatePackageError::AccessDenied(err.msg))
}
"BaseException" => return RusotoError::Service(CreatePackageError::Base(err.msg)),
"InternalException" => {
return RusotoError::Service(CreatePackageError::Internal(err.msg))
}
"InvalidTypeException" => {
return RusotoError::Service(CreatePackageError::InvalidType(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreatePackageError::LimitExceeded(err.msg))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(CreatePackageError::ResourceAlreadyExists(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreatePackageError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreatePackageError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreatePackageError::Base(ref cause) => write!(f, "{}", cause),
CreatePackageError::Internal(ref cause) => write!(f, "{}", cause),
CreatePackageError::InvalidType(ref cause) => write!(f, "{}", cause),
CreatePackageError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreatePackageError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreatePackageError {}
#[derive(Debug, PartialEq)]
pub enum DeleteElasticsearchDomainError {
Base(String),
Internal(String),
ResourceNotFound(String),
}
impl DeleteElasticsearchDomainError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteElasticsearchDomainError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BaseException" => {
return RusotoError::Service(DeleteElasticsearchDomainError::Base(err.msg))
}
"InternalException" => {
return RusotoError::Service(DeleteElasticsearchDomainError::Internal(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteElasticsearchDomainError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteElasticsearchDomainError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteElasticsearchDomainError::Base(ref cause) => write!(f, "{}", cause),
DeleteElasticsearchDomainError::Internal(ref cause) => write!(f, "{}", cause),
DeleteElasticsearchDomainError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteElasticsearchDomainError {}
#[derive(Debug, PartialEq)]
pub enum DeleteElasticsearchServiceRoleError {
Base(String),
Internal(String),
}
impl DeleteElasticsearchServiceRoleError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteElasticsearchServiceRoleError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BaseException" => {
return RusotoError::Service(DeleteElasticsearchServiceRoleError::Base(err.msg))
}
"InternalException" => {
return RusotoError::Service(DeleteElasticsearchServiceRoleError::Internal(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteElasticsearchServiceRoleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteElasticsearchServiceRoleError::Base(ref cause) => write!(f, "{}", cause),
DeleteElasticsearchServiceRoleError::Internal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteElasticsearchServiceRoleError {}
#[derive(Debug, PartialEq)]
pub enum DeleteInboundCrossClusterSearchConnectionError {
DisabledOperation(String),
ResourceNotFound(String),
}
impl DeleteInboundCrossClusterSearchConnectionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteInboundCrossClusterSearchConnectionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DisabledOperationException" => {
return RusotoError::Service(
DeleteInboundCrossClusterSearchConnectionError::DisabledOperation(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DeleteInboundCrossClusterSearchConnectionError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteInboundCrossClusterSearchConnectionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteInboundCrossClusterSearchConnectionError::DisabledOperation(ref cause) => {
write!(f, "{}", cause)
}
DeleteInboundCrossClusterSearchConnectionError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteInboundCrossClusterSearchConnectionError {}
#[derive(Debug, PartialEq)]
pub enum DeleteOutboundCrossClusterSearchConnectionError {
DisabledOperation(String),
ResourceNotFound(String),
}
impl DeleteOutboundCrossClusterSearchConnectionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteOutboundCrossClusterSearchConnectionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DisabledOperationException" => {
return RusotoError::Service(
DeleteOutboundCrossClusterSearchConnectionError::DisabledOperation(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DeleteOutboundCrossClusterSearchConnectionError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteOutboundCrossClusterSearchConnectionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteOutboundCrossClusterSearchConnectionError::DisabledOperation(ref cause) => {
write!(f, "{}", cause)
}
DeleteOutboundCrossClusterSearchConnectionError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteOutboundCrossClusterSearchConnectionError {}
#[derive(Debug, PartialEq)]
pub enum DeletePackageError {
AccessDenied(String),
Base(String),
Conflict(String),
Internal(String),
ResourceNotFound(String),
}
impl DeletePackageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeletePackageError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeletePackageError::AccessDenied(err.msg))
}
"BaseException" => return RusotoError::Service(DeletePackageError::Base(err.msg)),
"ConflictException" => {
return RusotoError::Service(DeletePackageError::Conflict(err.msg))
}
"InternalException" => {
return RusotoError::Service(DeletePackageError::Internal(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeletePackageError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeletePackageError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeletePackageError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeletePackageError::Base(ref cause) => write!(f, "{}", cause),
DeletePackageError::Conflict(ref cause) => write!(f, "{}", cause),
DeletePackageError::Internal(ref cause) => write!(f, "{}", cause),
DeletePackageError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeletePackageError {}
#[derive(Debug, PartialEq)]
pub enum DescribeElasticsearchDomainError {
Base(String),
Internal(String),
ResourceNotFound(String),
}
impl DescribeElasticsearchDomainError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeElasticsearchDomainError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BaseException" => {
return RusotoError::Service(DescribeElasticsearchDomainError::Base(err.msg))
}
"InternalException" => {
return RusotoError::Service(DescribeElasticsearchDomainError::Internal(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DescribeElasticsearchDomainError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeElasticsearchDomainError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeElasticsearchDomainError::Base(ref cause) => write!(f, "{}", cause),
DescribeElasticsearchDomainError::Internal(ref cause) => write!(f, "{}", cause),
DescribeElasticsearchDomainError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeElasticsearchDomainError {}
#[derive(Debug, PartialEq)]
pub enum DescribeElasticsearchDomainConfigError {
Base(String),
Internal(String),
ResourceNotFound(String),
}
impl DescribeElasticsearchDomainConfigError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeElasticsearchDomainConfigError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BaseException" => {
return RusotoError::Service(DescribeElasticsearchDomainConfigError::Base(
err.msg,
))
}
"InternalException" => {
return RusotoError::Service(DescribeElasticsearchDomainConfigError::Internal(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DescribeElasticsearchDomainConfigError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeElasticsearchDomainConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeElasticsearchDomainConfigError::Base(ref cause) => write!(f, "{}", cause),
DescribeElasticsearchDomainConfigError::Internal(ref cause) => write!(f, "{}", cause),
DescribeElasticsearchDomainConfigError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeElasticsearchDomainConfigError {}
#[derive(Debug, PartialEq)]
pub enum DescribeElasticsearchDomainsError {
Base(String),
Internal(String),
}
impl DescribeElasticsearchDomainsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeElasticsearchDomainsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BaseException" => {
return RusotoError::Service(DescribeElasticsearchDomainsError::Base(err.msg))
}
"InternalException" => {
return RusotoError::Service(DescribeElasticsearchDomainsError::Internal(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeElasticsearchDomainsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeElasticsearchDomainsError::Base(ref cause) => write!(f, "{}", cause),
DescribeElasticsearchDomainsError::Internal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeElasticsearchDomainsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeElasticsearchInstanceTypeLimitsError {
Base(String),
Internal(String),
InvalidType(String),
LimitExceeded(String),
ResourceNotFound(String),
}
impl DescribeElasticsearchInstanceTypeLimitsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeElasticsearchInstanceTypeLimitsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BaseException" => {
return RusotoError::Service(
DescribeElasticsearchInstanceTypeLimitsError::Base(err.msg),
)
}
"InternalException" => {
return RusotoError::Service(
DescribeElasticsearchInstanceTypeLimitsError::Internal(err.msg),
)
}
"InvalidTypeException" => {
return RusotoError::Service(
DescribeElasticsearchInstanceTypeLimitsError::InvalidType(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(
DescribeElasticsearchInstanceTypeLimitsError::LimitExceeded(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DescribeElasticsearchInstanceTypeLimitsError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeElasticsearchInstanceTypeLimitsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeElasticsearchInstanceTypeLimitsError::Base(ref cause) => write!(f, "{}", cause),
DescribeElasticsearchInstanceTypeLimitsError::Internal(ref cause) => {
write!(f, "{}", cause)
}
DescribeElasticsearchInstanceTypeLimitsError::InvalidType(ref cause) => {
write!(f, "{}", cause)
}
DescribeElasticsearchInstanceTypeLimitsError::LimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
DescribeElasticsearchInstanceTypeLimitsError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeElasticsearchInstanceTypeLimitsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeInboundCrossClusterSearchConnectionsError {
DisabledOperation(String),
InvalidPaginationToken(String),
}
impl DescribeInboundCrossClusterSearchConnectionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeInboundCrossClusterSearchConnectionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DisabledOperationException" => {
return RusotoError::Service(
DescribeInboundCrossClusterSearchConnectionsError::DisabledOperation(
err.msg,
),
)
}
"InvalidPaginationTokenException" => {
return RusotoError::Service(
DescribeInboundCrossClusterSearchConnectionsError::InvalidPaginationToken(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeInboundCrossClusterSearchConnectionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeInboundCrossClusterSearchConnectionsError::DisabledOperation(ref cause) => {
write!(f, "{}", cause)
}
DescribeInboundCrossClusterSearchConnectionsError::InvalidPaginationToken(
ref cause,
) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeInboundCrossClusterSearchConnectionsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeOutboundCrossClusterSearchConnectionsError {
DisabledOperation(String),
InvalidPaginationToken(String),
}
impl DescribeOutboundCrossClusterSearchConnectionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeOutboundCrossClusterSearchConnectionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DisabledOperationException" => {
return RusotoError::Service(
DescribeOutboundCrossClusterSearchConnectionsError::DisabledOperation(
err.msg,
),
)
}
"InvalidPaginationTokenException" => {
return RusotoError::Service(
DescribeOutboundCrossClusterSearchConnectionsError::InvalidPaginationToken(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeOutboundCrossClusterSearchConnectionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeOutboundCrossClusterSearchConnectionsError::DisabledOperation(ref cause) => {
write!(f, "{}", cause)
}
DescribeOutboundCrossClusterSearchConnectionsError::InvalidPaginationToken(
ref cause,
) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeOutboundCrossClusterSearchConnectionsError {}
#[derive(Debug, PartialEq)]
pub enum DescribePackagesError {
AccessDenied(String),
Base(String),
Internal(String),
ResourceNotFound(String),
}
impl DescribePackagesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribePackagesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DescribePackagesError::AccessDenied(err.msg))
}
"BaseException" => {
return RusotoError::Service(DescribePackagesError::Base(err.msg))
}
"InternalException" => {
return RusotoError::Service(DescribePackagesError::Internal(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribePackagesError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribePackagesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribePackagesError::AccessDenied(ref cause) => write!(f, "{}", cause),
DescribePackagesError::Base(ref cause) => write!(f, "{}", cause),
DescribePackagesError::Internal(ref cause) => write!(f, "{}", cause),
DescribePackagesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribePackagesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeReservedElasticsearchInstanceOfferingsError {
DisabledOperation(String),
Internal(String),
ResourceNotFound(String),
}
impl DescribeReservedElasticsearchInstanceOfferingsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeReservedElasticsearchInstanceOfferingsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DisabledOperationException" => {
return RusotoError::Service(
DescribeReservedElasticsearchInstanceOfferingsError::DisabledOperation(
err.msg,
),
)
}
"InternalException" => {
return RusotoError::Service(
DescribeReservedElasticsearchInstanceOfferingsError::Internal(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DescribeReservedElasticsearchInstanceOfferingsError::ResourceNotFound(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeReservedElasticsearchInstanceOfferingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeReservedElasticsearchInstanceOfferingsError::DisabledOperation(ref cause) => {
write!(f, "{}", cause)
}
DescribeReservedElasticsearchInstanceOfferingsError::Internal(ref cause) => {
write!(f, "{}", cause)
}
DescribeReservedElasticsearchInstanceOfferingsError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeReservedElasticsearchInstanceOfferingsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeReservedElasticsearchInstancesError {
DisabledOperation(String),
Internal(String),
ResourceNotFound(String),
}
impl DescribeReservedElasticsearchInstancesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeReservedElasticsearchInstancesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DisabledOperationException" => {
return RusotoError::Service(
DescribeReservedElasticsearchInstancesError::DisabledOperation(err.msg),
)
}
"InternalException" => {
return RusotoError::Service(
DescribeReservedElasticsearchInstancesError::Internal(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DescribeReservedElasticsearchInstancesError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeReservedElasticsearchInstancesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeReservedElasticsearchInstancesError::DisabledOperation(ref cause) => {
write!(f, "{}", cause)
}
DescribeReservedElasticsearchInstancesError::Internal(ref cause) => {
write!(f, "{}", cause)
}
DescribeReservedElasticsearchInstancesError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeReservedElasticsearchInstancesError {}
#[derive(Debug, PartialEq)]
pub enum DissociatePackageError {
AccessDenied(String),
Base(String),
Conflict(String),
Internal(String),
ResourceNotFound(String),
}
impl DissociatePackageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DissociatePackageError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DissociatePackageError::AccessDenied(err.msg))
}
"BaseException" => {
return RusotoError::Service(DissociatePackageError::Base(err.msg))
}
"ConflictException" => {
return RusotoError::Service(DissociatePackageError::Conflict(err.msg))
}
"InternalException" => {
return RusotoError::Service(DissociatePackageError::Internal(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DissociatePackageError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DissociatePackageError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DissociatePackageError::AccessDenied(ref cause) => write!(f, "{}", cause),
DissociatePackageError::Base(ref cause) => write!(f, "{}", cause),
DissociatePackageError::Conflict(ref cause) => write!(f, "{}", cause),
DissociatePackageError::Internal(ref cause) => write!(f, "{}", cause),
DissociatePackageError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DissociatePackageError {}
#[derive(Debug, PartialEq)]
pub enum GetCompatibleElasticsearchVersionsError {
Base(String),
DisabledOperation(String),
Internal(String),
ResourceNotFound(String),
}
impl GetCompatibleElasticsearchVersionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetCompatibleElasticsearchVersionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BaseException" => {
return RusotoError::Service(GetCompatibleElasticsearchVersionsError::Base(
err.msg,
))
}
"DisabledOperationException" => {
return RusotoError::Service(
GetCompatibleElasticsearchVersionsError::DisabledOperation(err.msg),
)
}
"InternalException" => {
return RusotoError::Service(GetCompatibleElasticsearchVersionsError::Internal(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(
GetCompatibleElasticsearchVersionsError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetCompatibleElasticsearchVersionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetCompatibleElasticsearchVersionsError::Base(ref cause) => write!(f, "{}", cause),
GetCompatibleElasticsearchVersionsError::DisabledOperation(ref cause) => {
write!(f, "{}", cause)
}
GetCompatibleElasticsearchVersionsError::Internal(ref cause) => write!(f, "{}", cause),
GetCompatibleElasticsearchVersionsError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetCompatibleElasticsearchVersionsError {}
#[derive(Debug, PartialEq)]
pub enum GetUpgradeHistoryError {
Base(String),
DisabledOperation(String),
Internal(String),
ResourceNotFound(String),
}
impl GetUpgradeHistoryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetUpgradeHistoryError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BaseException" => {
return RusotoError::Service(GetUpgradeHistoryError::Base(err.msg))
}
"DisabledOperationException" => {
return RusotoError::Service(GetUpgradeHistoryError::DisabledOperation(err.msg))
}
"InternalException" => {
return RusotoError::Service(GetUpgradeHistoryError::Internal(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetUpgradeHistoryError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetUpgradeHistoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetUpgradeHistoryError::Base(ref cause) => write!(f, "{}", cause),
GetUpgradeHistoryError::DisabledOperation(ref cause) => write!(f, "{}", cause),
GetUpgradeHistoryError::Internal(ref cause) => write!(f, "{}", cause),
GetUpgradeHistoryError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetUpgradeHistoryError {}
#[derive(Debug, PartialEq)]
pub enum GetUpgradeStatusError {
Base(String),
DisabledOperation(String),
Internal(String),
ResourceNotFound(String),
}
impl GetUpgradeStatusError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetUpgradeStatusError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BaseException" => {
return RusotoError::Service(GetUpgradeStatusError::Base(err.msg))
}
"DisabledOperationException" => {
return RusotoError::Service(GetUpgradeStatusError::DisabledOperation(err.msg))
}
"InternalException" => {
return RusotoError::Service(GetUpgradeStatusError::Internal(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetUpgradeStatusError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetUpgradeStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetUpgradeStatusError::Base(ref cause) => write!(f, "{}", cause),
GetUpgradeStatusError::DisabledOperation(ref cause) => write!(f, "{}", cause),
GetUpgradeStatusError::Internal(ref cause) => write!(f, "{}", cause),
GetUpgradeStatusError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetUpgradeStatusError {}
#[derive(Debug, PartialEq)]
pub enum ListDomainNamesError {
Base(String),
}
impl ListDomainNamesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDomainNamesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BaseException" => {
return RusotoError::Service(ListDomainNamesError::Base(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDomainNamesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDomainNamesError::Base(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDomainNamesError {}
#[derive(Debug, PartialEq)]
pub enum ListDomainsForPackageError {
AccessDenied(String),
Base(String),
Internal(String),
ResourceNotFound(String),
}
impl ListDomainsForPackageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDomainsForPackageError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListDomainsForPackageError::AccessDenied(err.msg))
}
"BaseException" => {
return RusotoError::Service(ListDomainsForPackageError::Base(err.msg))
}
"InternalException" => {
return RusotoError::Service(ListDomainsForPackageError::Internal(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListDomainsForPackageError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDomainsForPackageError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDomainsForPackageError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListDomainsForPackageError::Base(ref cause) => write!(f, "{}", cause),
ListDomainsForPackageError::Internal(ref cause) => write!(f, "{}", cause),
ListDomainsForPackageError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDomainsForPackageError {}
#[derive(Debug, PartialEq)]
pub enum ListElasticsearchInstanceTypesError {
Base(String),
Internal(String),
ResourceNotFound(String),
}
impl ListElasticsearchInstanceTypesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListElasticsearchInstanceTypesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BaseException" => {
return RusotoError::Service(ListElasticsearchInstanceTypesError::Base(err.msg))
}
"InternalException" => {
return RusotoError::Service(ListElasticsearchInstanceTypesError::Internal(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(
ListElasticsearchInstanceTypesError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListElasticsearchInstanceTypesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListElasticsearchInstanceTypesError::Base(ref cause) => write!(f, "{}", cause),
ListElasticsearchInstanceTypesError::Internal(ref cause) => write!(f, "{}", cause),
ListElasticsearchInstanceTypesError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListElasticsearchInstanceTypesError {}
#[derive(Debug, PartialEq)]
pub enum ListElasticsearchVersionsError {
Base(String),
Internal(String),
ResourceNotFound(String),
}
impl ListElasticsearchVersionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListElasticsearchVersionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BaseException" => {
return RusotoError::Service(ListElasticsearchVersionsError::Base(err.msg))
}
"InternalException" => {
return RusotoError::Service(ListElasticsearchVersionsError::Internal(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListElasticsearchVersionsError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListElasticsearchVersionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListElasticsearchVersionsError::Base(ref cause) => write!(f, "{}", cause),
ListElasticsearchVersionsError::Internal(ref cause) => write!(f, "{}", cause),
ListElasticsearchVersionsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListElasticsearchVersionsError {}
#[derive(Debug, PartialEq)]
pub enum ListPackagesForDomainError {
AccessDenied(String),
Base(String),
Internal(String),
ResourceNotFound(String),
}
impl ListPackagesForDomainError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListPackagesForDomainError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListPackagesForDomainError::AccessDenied(err.msg))
}
"BaseException" => {
return RusotoError::Service(ListPackagesForDomainError::Base(err.msg))
}
"InternalException" => {
return RusotoError::Service(ListPackagesForDomainError::Internal(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListPackagesForDomainError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListPackagesForDomainError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListPackagesForDomainError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListPackagesForDomainError::Base(ref cause) => write!(f, "{}", cause),
ListPackagesForDomainError::Internal(ref cause) => write!(f, "{}", cause),
ListPackagesForDomainError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListPackagesForDomainError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsError {
Base(String),
Internal(String),
ResourceNotFound(String),
}
impl ListTagsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BaseException" => return RusotoError::Service(ListTagsError::Base(err.msg)),
"InternalException" => {
return RusotoError::Service(ListTagsError::Internal(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListTagsError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsError::Base(ref cause) => write!(f, "{}", cause),
ListTagsError::Internal(ref cause) => write!(f, "{}", cause),
ListTagsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsError {}
#[derive(Debug, PartialEq)]
pub enum PurchaseReservedElasticsearchInstanceOfferingError {
DisabledOperation(String),
Internal(String),
LimitExceeded(String),
ResourceAlreadyExists(String),
ResourceNotFound(String),
}
impl PurchaseReservedElasticsearchInstanceOfferingError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PurchaseReservedElasticsearchInstanceOfferingError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DisabledOperationException" => {
return RusotoError::Service(
PurchaseReservedElasticsearchInstanceOfferingError::DisabledOperation(
err.msg,
),
)
}
"InternalException" => {
return RusotoError::Service(
PurchaseReservedElasticsearchInstanceOfferingError::Internal(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(
PurchaseReservedElasticsearchInstanceOfferingError::LimitExceeded(err.msg),
)
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(
PurchaseReservedElasticsearchInstanceOfferingError::ResourceAlreadyExists(
err.msg,
),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
PurchaseReservedElasticsearchInstanceOfferingError::ResourceNotFound(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PurchaseReservedElasticsearchInstanceOfferingError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PurchaseReservedElasticsearchInstanceOfferingError::DisabledOperation(ref cause) => {
write!(f, "{}", cause)
}
PurchaseReservedElasticsearchInstanceOfferingError::Internal(ref cause) => {
write!(f, "{}", cause)
}
PurchaseReservedElasticsearchInstanceOfferingError::LimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
PurchaseReservedElasticsearchInstanceOfferingError::ResourceAlreadyExists(
ref cause,
) => write!(f, "{}", cause),
PurchaseReservedElasticsearchInstanceOfferingError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PurchaseReservedElasticsearchInstanceOfferingError {}
#[derive(Debug, PartialEq)]
pub enum RejectInboundCrossClusterSearchConnectionError {
DisabledOperation(String),
ResourceNotFound(String),
}
impl RejectInboundCrossClusterSearchConnectionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<RejectInboundCrossClusterSearchConnectionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DisabledOperationException" => {
return RusotoError::Service(
RejectInboundCrossClusterSearchConnectionError::DisabledOperation(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
RejectInboundCrossClusterSearchConnectionError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RejectInboundCrossClusterSearchConnectionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RejectInboundCrossClusterSearchConnectionError::DisabledOperation(ref cause) => {
write!(f, "{}", cause)
}
RejectInboundCrossClusterSearchConnectionError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for RejectInboundCrossClusterSearchConnectionError {}
#[derive(Debug, PartialEq)]
pub enum RemoveTagsError {
Base(String),
Internal(String),
}
impl RemoveTagsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RemoveTagsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BaseException" => return RusotoError::Service(RemoveTagsError::Base(err.msg)),
"InternalException" => {
return RusotoError::Service(RemoveTagsError::Internal(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RemoveTagsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RemoveTagsError::Base(ref cause) => write!(f, "{}", cause),
RemoveTagsError::Internal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RemoveTagsError {}
#[derive(Debug, PartialEq)]
pub enum StartElasticsearchServiceSoftwareUpdateError {
Base(String),
Internal(String),
ResourceNotFound(String),
}
impl StartElasticsearchServiceSoftwareUpdateError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<StartElasticsearchServiceSoftwareUpdateError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BaseException" => {
return RusotoError::Service(
StartElasticsearchServiceSoftwareUpdateError::Base(err.msg),
)
}
"InternalException" => {
return RusotoError::Service(
StartElasticsearchServiceSoftwareUpdateError::Internal(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
StartElasticsearchServiceSoftwareUpdateError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartElasticsearchServiceSoftwareUpdateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartElasticsearchServiceSoftwareUpdateError::Base(ref cause) => write!(f, "{}", cause),
StartElasticsearchServiceSoftwareUpdateError::Internal(ref cause) => {
write!(f, "{}", cause)
}
StartElasticsearchServiceSoftwareUpdateError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for StartElasticsearchServiceSoftwareUpdateError {}
#[derive(Debug, PartialEq)]
pub enum UpdateElasticsearchDomainConfigError {
Base(String),
Internal(String),
InvalidType(String),
LimitExceeded(String),
ResourceNotFound(String),
}
impl UpdateElasticsearchDomainConfigError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateElasticsearchDomainConfigError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BaseException" => {
return RusotoError::Service(UpdateElasticsearchDomainConfigError::Base(
err.msg,
))
}
"InternalException" => {
return RusotoError::Service(UpdateElasticsearchDomainConfigError::Internal(
err.msg,
))
}
"InvalidTypeException" => {
return RusotoError::Service(UpdateElasticsearchDomainConfigError::InvalidType(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(
UpdateElasticsearchDomainConfigError::LimitExceeded(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
UpdateElasticsearchDomainConfigError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateElasticsearchDomainConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateElasticsearchDomainConfigError::Base(ref cause) => write!(f, "{}", cause),
UpdateElasticsearchDomainConfigError::Internal(ref cause) => write!(f, "{}", cause),
UpdateElasticsearchDomainConfigError::InvalidType(ref cause) => write!(f, "{}", cause),
UpdateElasticsearchDomainConfigError::LimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
UpdateElasticsearchDomainConfigError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateElasticsearchDomainConfigError {}
#[derive(Debug, PartialEq)]
pub enum UpgradeElasticsearchDomainError {
Base(String),
DisabledOperation(String),
Internal(String),
ResourceAlreadyExists(String),
ResourceNotFound(String),
}
impl UpgradeElasticsearchDomainError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpgradeElasticsearchDomainError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BaseException" => {
return RusotoError::Service(UpgradeElasticsearchDomainError::Base(err.msg))
}
"DisabledOperationException" => {
return RusotoError::Service(
UpgradeElasticsearchDomainError::DisabledOperation(err.msg),
)
}
"InternalException" => {
return RusotoError::Service(UpgradeElasticsearchDomainError::Internal(err.msg))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(
UpgradeElasticsearchDomainError::ResourceAlreadyExists(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpgradeElasticsearchDomainError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpgradeElasticsearchDomainError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpgradeElasticsearchDomainError::Base(ref cause) => write!(f, "{}", cause),
UpgradeElasticsearchDomainError::DisabledOperation(ref cause) => write!(f, "{}", cause),
UpgradeElasticsearchDomainError::Internal(ref cause) => write!(f, "{}", cause),
UpgradeElasticsearchDomainError::ResourceAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
UpgradeElasticsearchDomainError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpgradeElasticsearchDomainError {}
#[async_trait]
pub trait Es {
async fn accept_inbound_cross_cluster_search_connection(
&self,
input: AcceptInboundCrossClusterSearchConnectionRequest,
) -> Result<
AcceptInboundCrossClusterSearchConnectionResponse,
RusotoError<AcceptInboundCrossClusterSearchConnectionError>,
>;
async fn add_tags(&self, input: AddTagsRequest) -> Result<(), RusotoError<AddTagsError>>;
async fn associate_package(
&self,
input: AssociatePackageRequest,
) -> Result<AssociatePackageResponse, RusotoError<AssociatePackageError>>;
async fn cancel_elasticsearch_service_software_update(
&self,
input: CancelElasticsearchServiceSoftwareUpdateRequest,
) -> Result<
CancelElasticsearchServiceSoftwareUpdateResponse,
RusotoError<CancelElasticsearchServiceSoftwareUpdateError>,
>;
async fn create_elasticsearch_domain(
&self,
input: CreateElasticsearchDomainRequest,
) -> Result<CreateElasticsearchDomainResponse, RusotoError<CreateElasticsearchDomainError>>;
async fn create_outbound_cross_cluster_search_connection(
&self,
input: CreateOutboundCrossClusterSearchConnectionRequest,
) -> Result<
CreateOutboundCrossClusterSearchConnectionResponse,
RusotoError<CreateOutboundCrossClusterSearchConnectionError>,
>;
async fn create_package(
&self,
input: CreatePackageRequest,
) -> Result<CreatePackageResponse, RusotoError<CreatePackageError>>;
async fn delete_elasticsearch_domain(
&self,
input: DeleteElasticsearchDomainRequest,
) -> Result<DeleteElasticsearchDomainResponse, RusotoError<DeleteElasticsearchDomainError>>;
async fn delete_elasticsearch_service_role(
&self,
) -> Result<(), RusotoError<DeleteElasticsearchServiceRoleError>>;
async fn delete_inbound_cross_cluster_search_connection(
&self,
input: DeleteInboundCrossClusterSearchConnectionRequest,
) -> Result<
DeleteInboundCrossClusterSearchConnectionResponse,
RusotoError<DeleteInboundCrossClusterSearchConnectionError>,
>;
async fn delete_outbound_cross_cluster_search_connection(
&self,
input: DeleteOutboundCrossClusterSearchConnectionRequest,
) -> Result<
DeleteOutboundCrossClusterSearchConnectionResponse,
RusotoError<DeleteOutboundCrossClusterSearchConnectionError>,
>;
async fn delete_package(
&self,
input: DeletePackageRequest,
) -> Result<DeletePackageResponse, RusotoError<DeletePackageError>>;
async fn describe_elasticsearch_domain(
&self,
input: DescribeElasticsearchDomainRequest,
) -> Result<DescribeElasticsearchDomainResponse, RusotoError<DescribeElasticsearchDomainError>>;
async fn describe_elasticsearch_domain_config(
&self,
input: DescribeElasticsearchDomainConfigRequest,
) -> Result<
DescribeElasticsearchDomainConfigResponse,
RusotoError<DescribeElasticsearchDomainConfigError>,
>;
async fn describe_elasticsearch_domains(
&self,
input: DescribeElasticsearchDomainsRequest,
) -> Result<DescribeElasticsearchDomainsResponse, RusotoError<DescribeElasticsearchDomainsError>>;
async fn describe_elasticsearch_instance_type_limits(
&self,
input: DescribeElasticsearchInstanceTypeLimitsRequest,
) -> Result<
DescribeElasticsearchInstanceTypeLimitsResponse,
RusotoError<DescribeElasticsearchInstanceTypeLimitsError>,
>;
async fn describe_inbound_cross_cluster_search_connections(
&self,
input: DescribeInboundCrossClusterSearchConnectionsRequest,
) -> Result<
DescribeInboundCrossClusterSearchConnectionsResponse,
RusotoError<DescribeInboundCrossClusterSearchConnectionsError>,
>;
async fn describe_outbound_cross_cluster_search_connections(
&self,
input: DescribeOutboundCrossClusterSearchConnectionsRequest,
) -> Result<
DescribeOutboundCrossClusterSearchConnectionsResponse,
RusotoError<DescribeOutboundCrossClusterSearchConnectionsError>,
>;
async fn describe_packages(
&self,
input: DescribePackagesRequest,
) -> Result<DescribePackagesResponse, RusotoError<DescribePackagesError>>;
async fn describe_reserved_elasticsearch_instance_offerings(
&self,
input: DescribeReservedElasticsearchInstanceOfferingsRequest,
) -> Result<
DescribeReservedElasticsearchInstanceOfferingsResponse,
RusotoError<DescribeReservedElasticsearchInstanceOfferingsError>,
>;
async fn describe_reserved_elasticsearch_instances(
&self,
input: DescribeReservedElasticsearchInstancesRequest,
) -> Result<
DescribeReservedElasticsearchInstancesResponse,
RusotoError<DescribeReservedElasticsearchInstancesError>,
>;
async fn dissociate_package(
&self,
input: DissociatePackageRequest,
) -> Result<DissociatePackageResponse, RusotoError<DissociatePackageError>>;
async fn get_compatible_elasticsearch_versions(
&self,
input: GetCompatibleElasticsearchVersionsRequest,
) -> Result<
GetCompatibleElasticsearchVersionsResponse,
RusotoError<GetCompatibleElasticsearchVersionsError>,
>;
async fn get_upgrade_history(
&self,
input: GetUpgradeHistoryRequest,
) -> Result<GetUpgradeHistoryResponse, RusotoError<GetUpgradeHistoryError>>;
async fn get_upgrade_status(
&self,
input: GetUpgradeStatusRequest,
) -> Result<GetUpgradeStatusResponse, RusotoError<GetUpgradeStatusError>>;
async fn list_domain_names(
&self,
) -> Result<ListDomainNamesResponse, RusotoError<ListDomainNamesError>>;
async fn list_domains_for_package(
&self,
input: ListDomainsForPackageRequest,
) -> Result<ListDomainsForPackageResponse, RusotoError<ListDomainsForPackageError>>;
async fn list_elasticsearch_instance_types(
&self,
input: ListElasticsearchInstanceTypesRequest,
) -> Result<
ListElasticsearchInstanceTypesResponse,
RusotoError<ListElasticsearchInstanceTypesError>,
>;
async fn list_elasticsearch_versions(
&self,
input: ListElasticsearchVersionsRequest,
) -> Result<ListElasticsearchVersionsResponse, RusotoError<ListElasticsearchVersionsError>>;
async fn list_packages_for_domain(
&self,
input: ListPackagesForDomainRequest,
) -> Result<ListPackagesForDomainResponse, RusotoError<ListPackagesForDomainError>>;
async fn list_tags(
&self,
input: ListTagsRequest,
) -> Result<ListTagsResponse, RusotoError<ListTagsError>>;
async fn purchase_reserved_elasticsearch_instance_offering(
&self,
input: PurchaseReservedElasticsearchInstanceOfferingRequest,
) -> Result<
PurchaseReservedElasticsearchInstanceOfferingResponse,
RusotoError<PurchaseReservedElasticsearchInstanceOfferingError>,
>;
async fn reject_inbound_cross_cluster_search_connection(
&self,
input: RejectInboundCrossClusterSearchConnectionRequest,
) -> Result<
RejectInboundCrossClusterSearchConnectionResponse,
RusotoError<RejectInboundCrossClusterSearchConnectionError>,
>;
async fn remove_tags(
&self,
input: RemoveTagsRequest,
) -> Result<(), RusotoError<RemoveTagsError>>;
async fn start_elasticsearch_service_software_update(
&self,
input: StartElasticsearchServiceSoftwareUpdateRequest,
) -> Result<
StartElasticsearchServiceSoftwareUpdateResponse,
RusotoError<StartElasticsearchServiceSoftwareUpdateError>,
>;
async fn update_elasticsearch_domain_config(
&self,
input: UpdateElasticsearchDomainConfigRequest,
) -> Result<
UpdateElasticsearchDomainConfigResponse,
RusotoError<UpdateElasticsearchDomainConfigError>,
>;
async fn upgrade_elasticsearch_domain(
&self,
input: UpgradeElasticsearchDomainRequest,
) -> Result<UpgradeElasticsearchDomainResponse, RusotoError<UpgradeElasticsearchDomainError>>;
}
#[derive(Clone)]
pub struct EsClient {
client: Client,
region: region::Region,
}
impl EsClient {
pub fn new(region: region::Region) -> EsClient {
EsClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> EsClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
EsClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> EsClient {
EsClient { client, region }
}
}
#[async_trait]
impl Es for EsClient {
#[allow(unused_mut)]
async fn accept_inbound_cross_cluster_search_connection(
&self,
input: AcceptInboundCrossClusterSearchConnectionRequest,
) -> Result<
AcceptInboundCrossClusterSearchConnectionResponse,
RusotoError<AcceptInboundCrossClusterSearchConnectionError>,
> {
let request_uri = format!(
"/2015-01-01/es/ccs/inboundConnection/{connection_id}/accept",
connection_id = input.cross_cluster_search_connection_id
);
let mut request = SignedRequest::new("PUT", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<AcceptInboundCrossClusterSearchConnectionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(AcceptInboundCrossClusterSearchConnectionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn add_tags(&self, input: AddTagsRequest) -> Result<(), RusotoError<AddTagsError>> {
let request_uri = "/2015-01-01/tags";
let mut request = SignedRequest::new("POST", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(AddTagsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn associate_package(
&self,
input: AssociatePackageRequest,
) -> Result<AssociatePackageResponse, RusotoError<AssociatePackageError>> {
let request_uri = format!(
"/2015-01-01/packages/associate/{package_id}/{domain_name}",
domain_name = input.domain_name,
package_id = input.package_id
);
let mut request = SignedRequest::new("POST", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<AssociatePackageResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(AssociatePackageError::from_response(response))
}
}
#[allow(unused_mut)]
async fn cancel_elasticsearch_service_software_update(
&self,
input: CancelElasticsearchServiceSoftwareUpdateRequest,
) -> Result<
CancelElasticsearchServiceSoftwareUpdateResponse,
RusotoError<CancelElasticsearchServiceSoftwareUpdateError>,
> {
let request_uri = "/2015-01-01/es/serviceSoftwareUpdate/cancel";
let mut request = SignedRequest::new("POST", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CancelElasticsearchServiceSoftwareUpdateResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CancelElasticsearchServiceSoftwareUpdateError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_elasticsearch_domain(
&self,
input: CreateElasticsearchDomainRequest,
) -> Result<CreateElasticsearchDomainResponse, RusotoError<CreateElasticsearchDomainError>>
{
let request_uri = "/2015-01-01/es/domain";
let mut request = SignedRequest::new("POST", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateElasticsearchDomainResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateElasticsearchDomainError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_outbound_cross_cluster_search_connection(
&self,
input: CreateOutboundCrossClusterSearchConnectionRequest,
) -> Result<
CreateOutboundCrossClusterSearchConnectionResponse,
RusotoError<CreateOutboundCrossClusterSearchConnectionError>,
> {
let request_uri = "/2015-01-01/es/ccs/outboundConnection";
let mut request = SignedRequest::new("POST", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateOutboundCrossClusterSearchConnectionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateOutboundCrossClusterSearchConnectionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_package(
&self,
input: CreatePackageRequest,
) -> Result<CreatePackageResponse, RusotoError<CreatePackageError>> {
let request_uri = "/2015-01-01/packages";
let mut request = SignedRequest::new("POST", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreatePackageResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreatePackageError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_elasticsearch_domain(
&self,
input: DeleteElasticsearchDomainRequest,
) -> Result<DeleteElasticsearchDomainResponse, RusotoError<DeleteElasticsearchDomainError>>
{
let request_uri = format!(
"/2015-01-01/es/domain/{domain_name}",
domain_name = input.domain_name
);
let mut request = SignedRequest::new("DELETE", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteElasticsearchDomainResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteElasticsearchDomainError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_elasticsearch_service_role(
&self,
) -> Result<(), RusotoError<DeleteElasticsearchServiceRoleError>> {
let request_uri = "/2015-01-01/es/role";
let mut request = SignedRequest::new("DELETE", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteElasticsearchServiceRoleError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_inbound_cross_cluster_search_connection(
&self,
input: DeleteInboundCrossClusterSearchConnectionRequest,
) -> Result<
DeleteInboundCrossClusterSearchConnectionResponse,
RusotoError<DeleteInboundCrossClusterSearchConnectionError>,
> {
let request_uri = format!(
"/2015-01-01/es/ccs/inboundConnection/{connection_id}",
connection_id = input.cross_cluster_search_connection_id
);
let mut request = SignedRequest::new("DELETE", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteInboundCrossClusterSearchConnectionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteInboundCrossClusterSearchConnectionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_outbound_cross_cluster_search_connection(
&self,
input: DeleteOutboundCrossClusterSearchConnectionRequest,
) -> Result<
DeleteOutboundCrossClusterSearchConnectionResponse,
RusotoError<DeleteOutboundCrossClusterSearchConnectionError>,
> {
let request_uri = format!(
"/2015-01-01/es/ccs/outboundConnection/{connection_id}",
connection_id = input.cross_cluster_search_connection_id
);
let mut request = SignedRequest::new("DELETE", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteOutboundCrossClusterSearchConnectionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteOutboundCrossClusterSearchConnectionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_package(
&self,
input: DeletePackageRequest,
) -> Result<DeletePackageResponse, RusotoError<DeletePackageError>> {
let request_uri = format!(
"/2015-01-01/packages/{package_id}",
package_id = input.package_id
);
let mut request = SignedRequest::new("DELETE", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeletePackageResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeletePackageError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_elasticsearch_domain(
&self,
input: DescribeElasticsearchDomainRequest,
) -> Result<DescribeElasticsearchDomainResponse, RusotoError<DescribeElasticsearchDomainError>>
{
let request_uri = format!(
"/2015-01-01/es/domain/{domain_name}",
domain_name = input.domain_name
);
let mut request = SignedRequest::new("GET", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeElasticsearchDomainResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeElasticsearchDomainError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_elasticsearch_domain_config(
&self,
input: DescribeElasticsearchDomainConfigRequest,
) -> Result<
DescribeElasticsearchDomainConfigResponse,
RusotoError<DescribeElasticsearchDomainConfigError>,
> {
let request_uri = format!(
"/2015-01-01/es/domain/{domain_name}/config",
domain_name = input.domain_name
);
let mut request = SignedRequest::new("GET", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeElasticsearchDomainConfigResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeElasticsearchDomainConfigError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn describe_elasticsearch_domains(
&self,
input: DescribeElasticsearchDomainsRequest,
) -> Result<DescribeElasticsearchDomainsResponse, RusotoError<DescribeElasticsearchDomainsError>>
{
let request_uri = "/2015-01-01/es/domain-info";
let mut request = SignedRequest::new("POST", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeElasticsearchDomainsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeElasticsearchDomainsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_elasticsearch_instance_type_limits(
&self,
input: DescribeElasticsearchInstanceTypeLimitsRequest,
) -> Result<
DescribeElasticsearchInstanceTypeLimitsResponse,
RusotoError<DescribeElasticsearchInstanceTypeLimitsError>,
> {
let request_uri = format!(
"/2015-01-01/es/instanceTypeLimits/{elasticsearch_version}/{instance_type}",
elasticsearch_version = input.elasticsearch_version,
instance_type = input.instance_type
);
let mut request = SignedRequest::new("GET", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.domain_name {
params.put("domainName", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeElasticsearchInstanceTypeLimitsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeElasticsearchInstanceTypeLimitsError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn describe_inbound_cross_cluster_search_connections(
&self,
input: DescribeInboundCrossClusterSearchConnectionsRequest,
) -> Result<
DescribeInboundCrossClusterSearchConnectionsResponse,
RusotoError<DescribeInboundCrossClusterSearchConnectionsError>,
> {
let request_uri = "/2015-01-01/es/ccs/inboundConnection/search";
let mut request = SignedRequest::new("POST", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeInboundCrossClusterSearchConnectionsResponse, _>(
)?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeInboundCrossClusterSearchConnectionsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_outbound_cross_cluster_search_connections(
&self,
input: DescribeOutboundCrossClusterSearchConnectionsRequest,
) -> Result<
DescribeOutboundCrossClusterSearchConnectionsResponse,
RusotoError<DescribeOutboundCrossClusterSearchConnectionsError>,
> {
let request_uri = "/2015-01-01/es/ccs/outboundConnection/search";
let mut request = SignedRequest::new("POST", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeOutboundCrossClusterSearchConnectionsResponse, _>(
)?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeOutboundCrossClusterSearchConnectionsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_packages(
&self,
input: DescribePackagesRequest,
) -> Result<DescribePackagesResponse, RusotoError<DescribePackagesError>> {
let request_uri = "/2015-01-01/packages/describe";
let mut request = SignedRequest::new("POST", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribePackagesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribePackagesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_reserved_elasticsearch_instance_offerings(
&self,
input: DescribeReservedElasticsearchInstanceOfferingsRequest,
) -> Result<
DescribeReservedElasticsearchInstanceOfferingsResponse,
RusotoError<DescribeReservedElasticsearchInstanceOfferingsError>,
> {
let request_uri = "/2015-01-01/es/reservedInstanceOfferings";
let mut request = SignedRequest::new("GET", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
if let Some(ref x) = input.reserved_elasticsearch_instance_offering_id {
params.put("offeringId", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeReservedElasticsearchInstanceOfferingsResponse, _>(
)?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeReservedElasticsearchInstanceOfferingsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_reserved_elasticsearch_instances(
&self,
input: DescribeReservedElasticsearchInstancesRequest,
) -> Result<
DescribeReservedElasticsearchInstancesResponse,
RusotoError<DescribeReservedElasticsearchInstancesError>,
> {
let request_uri = "/2015-01-01/es/reservedInstances";
let mut request = SignedRequest::new("GET", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
if let Some(ref x) = input.reserved_elasticsearch_instance_id {
params.put("reservationId", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeReservedElasticsearchInstancesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeReservedElasticsearchInstancesError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn dissociate_package(
&self,
input: DissociatePackageRequest,
) -> Result<DissociatePackageResponse, RusotoError<DissociatePackageError>> {
let request_uri = format!(
"/2015-01-01/packages/dissociate/{package_id}/{domain_name}",
domain_name = input.domain_name,
package_id = input.package_id
);
let mut request = SignedRequest::new("POST", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DissociatePackageResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DissociatePackageError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_compatible_elasticsearch_versions(
&self,
input: GetCompatibleElasticsearchVersionsRequest,
) -> Result<
GetCompatibleElasticsearchVersionsResponse,
RusotoError<GetCompatibleElasticsearchVersionsError>,
> {
let request_uri = "/2015-01-01/es/compatibleVersions";
let mut request = SignedRequest::new("GET", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.domain_name {
params.put("domainName", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetCompatibleElasticsearchVersionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetCompatibleElasticsearchVersionsError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn get_upgrade_history(
&self,
input: GetUpgradeHistoryRequest,
) -> Result<GetUpgradeHistoryResponse, RusotoError<GetUpgradeHistoryError>> {
let request_uri = format!(
"/2015-01-01/es/upgradeDomain/{domain_name}/history",
domain_name = input.domain_name
);
let mut request = SignedRequest::new("GET", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetUpgradeHistoryResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetUpgradeHistoryError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_upgrade_status(
&self,
input: GetUpgradeStatusRequest,
) -> Result<GetUpgradeStatusResponse, RusotoError<GetUpgradeStatusError>> {
let request_uri = format!(
"/2015-01-01/es/upgradeDomain/{domain_name}/status",
domain_name = input.domain_name
);
let mut request = SignedRequest::new("GET", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetUpgradeStatusResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetUpgradeStatusError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_domain_names(
&self,
) -> Result<ListDomainNamesResponse, RusotoError<ListDomainNamesError>> {
let request_uri = "/2015-01-01/domain";
let mut request = SignedRequest::new("GET", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListDomainNamesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListDomainNamesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_domains_for_package(
&self,
input: ListDomainsForPackageRequest,
) -> Result<ListDomainsForPackageResponse, RusotoError<ListDomainsForPackageError>> {
let request_uri = format!(
"/2015-01-01/packages/{package_id}/domains",
package_id = input.package_id
);
let mut request = SignedRequest::new("GET", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListDomainsForPackageResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListDomainsForPackageError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_elasticsearch_instance_types(
&self,
input: ListElasticsearchInstanceTypesRequest,
) -> Result<
ListElasticsearchInstanceTypesResponse,
RusotoError<ListElasticsearchInstanceTypesError>,
> {
let request_uri = format!(
"/2015-01-01/es/instanceTypes/{elasticsearch_version}",
elasticsearch_version = input.elasticsearch_version
);
let mut request = SignedRequest::new("GET", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.domain_name {
params.put("domainName", x);
}
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListElasticsearchInstanceTypesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListElasticsearchInstanceTypesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_elasticsearch_versions(
&self,
input: ListElasticsearchVersionsRequest,
) -> Result<ListElasticsearchVersionsResponse, RusotoError<ListElasticsearchVersionsError>>
{
let request_uri = "/2015-01-01/es/versions";
let mut request = SignedRequest::new("GET", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListElasticsearchVersionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListElasticsearchVersionsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_packages_for_domain(
&self,
input: ListPackagesForDomainRequest,
) -> Result<ListPackagesForDomainResponse, RusotoError<ListPackagesForDomainError>> {
let request_uri = format!(
"/2015-01-01/domain/{domain_name}/packages",
domain_name = input.domain_name
);
let mut request = SignedRequest::new("GET", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListPackagesForDomainResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListPackagesForDomainError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_tags(
&self,
input: ListTagsRequest,
) -> Result<ListTagsResponse, RusotoError<ListTagsError>> {
let request_uri = "/2015-01-01/tags/";
let mut request = SignedRequest::new("GET", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put("arn", &input.arn);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListTagsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListTagsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn purchase_reserved_elasticsearch_instance_offering(
&self,
input: PurchaseReservedElasticsearchInstanceOfferingRequest,
) -> Result<
PurchaseReservedElasticsearchInstanceOfferingResponse,
RusotoError<PurchaseReservedElasticsearchInstanceOfferingError>,
> {
let request_uri = "/2015-01-01/es/purchaseReservedInstanceOffering";
let mut request = SignedRequest::new("POST", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PurchaseReservedElasticsearchInstanceOfferingResponse, _>(
)?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PurchaseReservedElasticsearchInstanceOfferingError::from_response(response))
}
}
#[allow(unused_mut)]
async fn reject_inbound_cross_cluster_search_connection(
&self,
input: RejectInboundCrossClusterSearchConnectionRequest,
) -> Result<
RejectInboundCrossClusterSearchConnectionResponse,
RusotoError<RejectInboundCrossClusterSearchConnectionError>,
> {
let request_uri = format!(
"/2015-01-01/es/ccs/inboundConnection/{connection_id}/reject",
connection_id = input.cross_cluster_search_connection_id
);
let mut request = SignedRequest::new("PUT", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<RejectInboundCrossClusterSearchConnectionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(RejectInboundCrossClusterSearchConnectionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn remove_tags(
&self,
input: RemoveTagsRequest,
) -> Result<(), RusotoError<RemoveTagsError>> {
let request_uri = "/2015-01-01/tags-removal";
let mut request = SignedRequest::new("POST", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(RemoveTagsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn start_elasticsearch_service_software_update(
&self,
input: StartElasticsearchServiceSoftwareUpdateRequest,
) -> Result<
StartElasticsearchServiceSoftwareUpdateResponse,
RusotoError<StartElasticsearchServiceSoftwareUpdateError>,
> {
let request_uri = "/2015-01-01/es/serviceSoftwareUpdate/start";
let mut request = SignedRequest::new("POST", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<StartElasticsearchServiceSoftwareUpdateResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(StartElasticsearchServiceSoftwareUpdateError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn update_elasticsearch_domain_config(
&self,
input: UpdateElasticsearchDomainConfigRequest,
) -> Result<
UpdateElasticsearchDomainConfigResponse,
RusotoError<UpdateElasticsearchDomainConfigError>,
> {
let request_uri = format!(
"/2015-01-01/es/domain/{domain_name}/config",
domain_name = input.domain_name
);
let mut request = SignedRequest::new("POST", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateElasticsearchDomainConfigResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateElasticsearchDomainConfigError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn upgrade_elasticsearch_domain(
&self,
input: UpgradeElasticsearchDomainRequest,
) -> Result<UpgradeElasticsearchDomainResponse, RusotoError<UpgradeElasticsearchDomainError>>
{
let request_uri = "/2015-01-01/es/upgradeDomain";
let mut request = SignedRequest::new("POST", "es", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpgradeElasticsearchDomainResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpgradeElasticsearchDomainError::from_response(response))
}
}
}