use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::proto;
use rusoto_core::request::HttpResponse;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
impl DirectoryServiceClient {
fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
let mut request = SignedRequest::new(http_method, "ds", &self.region, request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request
}
async fn sign_and_dispatch<E>(
&self,
request: SignedRequest,
from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
) -> Result<HttpResponse, RusotoError<E>> {
let mut response = self.client.sign_and_dispatch(request).await?;
if !response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
return Err(from_response(response));
}
Ok(response)
}
}
use serde_json;
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AcceptSharedDirectoryRequest {
#[serde(rename = "SharedDirectoryId")]
pub shared_directory_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AcceptSharedDirectoryResult {
#[serde(rename = "SharedDirectory")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shared_directory: Option<SharedDirectory>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AddIpRoutesRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "IpRoutes")]
pub ip_routes: Vec<IpRoute>,
#[serde(rename = "UpdateSecurityGroupForDirectoryControllers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub update_security_group_for_directory_controllers: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AddIpRoutesResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AddTagsToResourceRequest {
#[serde(rename = "ResourceId")]
pub resource_id: String,
#[serde(rename = "Tags")]
pub tags: Vec<Tag>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AddTagsToResourceResult {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Attribute {
#[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<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CancelSchemaExtensionRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "SchemaExtensionId")]
pub schema_extension_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CancelSchemaExtensionResult {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Certificate {
#[serde(rename = "CertificateId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_id: Option<String>,
#[serde(rename = "CommonName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub common_name: Option<String>,
#[serde(rename = "ExpiryDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expiry_date_time: Option<f64>,
#[serde(rename = "RegisteredDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registered_date_time: Option<f64>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "StateReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state_reason: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CertificateInfo {
#[serde(rename = "CertificateId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_id: Option<String>,
#[serde(rename = "CommonName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub common_name: Option<String>,
#[serde(rename = "ExpiryDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expiry_date_time: Option<f64>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Computer {
#[serde(rename = "ComputerAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub computer_attributes: Option<Vec<Attribute>>,
#[serde(rename = "ComputerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub computer_id: Option<String>,
#[serde(rename = "ComputerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub computer_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConditionalForwarder {
#[serde(rename = "DnsIpAddrs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dns_ip_addrs: Option<Vec<String>>,
#[serde(rename = "RemoteDomainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remote_domain_name: Option<String>,
#[serde(rename = "ReplicationScope")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replication_scope: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ConnectDirectoryRequest {
#[serde(rename = "ConnectSettings")]
pub connect_settings: DirectoryConnectSettings,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Password")]
pub password: String,
#[serde(rename = "ShortName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub short_name: Option<String>,
#[serde(rename = "Size")]
pub size: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConnectDirectoryResult {
#[serde(rename = "DirectoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateAliasRequest {
#[serde(rename = "Alias")]
pub alias: String,
#[serde(rename = "DirectoryId")]
pub directory_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateAliasResult {
#[serde(rename = "Alias")]
#[serde(skip_serializing_if = "Option::is_none")]
pub alias: Option<String>,
#[serde(rename = "DirectoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateComputerRequest {
#[serde(rename = "ComputerAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub computer_attributes: Option<Vec<Attribute>>,
#[serde(rename = "ComputerName")]
pub computer_name: String,
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "OrganizationalUnitDistinguishedName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organizational_unit_distinguished_name: Option<String>,
#[serde(rename = "Password")]
pub password: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateComputerResult {
#[serde(rename = "Computer")]
#[serde(skip_serializing_if = "Option::is_none")]
pub computer: Option<Computer>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateConditionalForwarderRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "DnsIpAddrs")]
pub dns_ip_addrs: Vec<String>,
#[serde(rename = "RemoteDomainName")]
pub remote_domain_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateConditionalForwarderResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDirectoryRequest {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Password")]
pub password: String,
#[serde(rename = "ShortName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub short_name: Option<String>,
#[serde(rename = "Size")]
pub size: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "VpcSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_settings: Option<DirectoryVpcSettings>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDirectoryResult {
#[serde(rename = "DirectoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateLogSubscriptionRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "LogGroupName")]
pub log_group_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateLogSubscriptionResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateMicrosoftADRequest {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Edition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub edition: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Password")]
pub password: String,
#[serde(rename = "ShortName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub short_name: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "VpcSettings")]
pub vpc_settings: DirectoryVpcSettings,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateMicrosoftADResult {
#[serde(rename = "DirectoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateSnapshotRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateSnapshotResult {
#[serde(rename = "SnapshotId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snapshot_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateTrustRequest {
#[serde(rename = "ConditionalForwarderIpAddrs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conditional_forwarder_ip_addrs: Option<Vec<String>>,
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "RemoteDomainName")]
pub remote_domain_name: String,
#[serde(rename = "SelectiveAuth")]
#[serde(skip_serializing_if = "Option::is_none")]
pub selective_auth: Option<String>,
#[serde(rename = "TrustDirection")]
pub trust_direction: String,
#[serde(rename = "TrustPassword")]
pub trust_password: String,
#[serde(rename = "TrustType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub trust_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateTrustResult {
#[serde(rename = "TrustId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub trust_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteConditionalForwarderRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "RemoteDomainName")]
pub remote_domain_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteConditionalForwarderResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDirectoryRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteDirectoryResult {
#[serde(rename = "DirectoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteLogSubscriptionRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteLogSubscriptionResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteSnapshotRequest {
#[serde(rename = "SnapshotId")]
pub snapshot_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteSnapshotResult {
#[serde(rename = "SnapshotId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snapshot_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteTrustRequest {
#[serde(rename = "DeleteAssociatedConditionalForwarder")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delete_associated_conditional_forwarder: Option<bool>,
#[serde(rename = "TrustId")]
pub trust_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteTrustResult {
#[serde(rename = "TrustId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub trust_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeregisterCertificateRequest {
#[serde(rename = "CertificateId")]
pub certificate_id: String,
#[serde(rename = "DirectoryId")]
pub directory_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeregisterCertificateResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeregisterEventTopicRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "TopicName")]
pub topic_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeregisterEventTopicResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeCertificateRequest {
#[serde(rename = "CertificateId")]
pub certificate_id: String,
#[serde(rename = "DirectoryId")]
pub directory_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeCertificateResult {
#[serde(rename = "Certificate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate: Option<Certificate>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeConditionalForwardersRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "RemoteDomainNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remote_domain_names: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeConditionalForwardersResult {
#[serde(rename = "ConditionalForwarders")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conditional_forwarders: Option<Vec<ConditionalForwarder>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeDirectoriesRequest {
#[serde(rename = "DirectoryIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_ids: Option<Vec<String>>,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: 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 DescribeDirectoriesResult {
#[serde(rename = "DirectoryDescriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_descriptions: Option<Vec<DirectoryDescription>>,
#[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 DescribeDomainControllersRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "DomainControllerIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_controller_ids: Option<Vec<String>>,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: 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 DescribeDomainControllersResult {
#[serde(rename = "DomainControllers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_controllers: Option<Vec<DomainController>>,
#[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 DescribeEventTopicsRequest {
#[serde(rename = "DirectoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_id: Option<String>,
#[serde(rename = "TopicNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub topic_names: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeEventTopicsResult {
#[serde(rename = "EventTopics")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_topics: Option<Vec<EventTopic>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeLDAPSSettingsRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeLDAPSSettingsResult {
#[serde(rename = "LDAPSSettingsInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ldaps_settings_info: Option<Vec<LDAPSSettingInfo>>,
#[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 DescribeSharedDirectoriesRequest {
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "OwnerDirectoryId")]
pub owner_directory_id: String,
#[serde(rename = "SharedDirectoryIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shared_directory_ids: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeSharedDirectoriesResult {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "SharedDirectories")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shared_directories: Option<Vec<SharedDirectory>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeSnapshotsRequest {
#[serde(rename = "DirectoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_id: Option<String>,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "SnapshotIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snapshot_ids: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeSnapshotsResult {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Snapshots")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snapshots: Option<Vec<Snapshot>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeTrustsRequest {
#[serde(rename = "DirectoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_id: Option<String>,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "TrustIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub trust_ids: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeTrustsResult {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Trusts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub trusts: Option<Vec<Trust>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DirectoryConnectSettings {
#[serde(rename = "CustomerDnsIps")]
pub customer_dns_ips: Vec<String>,
#[serde(rename = "CustomerUserName")]
pub customer_user_name: String,
#[serde(rename = "SubnetIds")]
pub subnet_ids: Vec<String>,
#[serde(rename = "VpcId")]
pub vpc_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DirectoryConnectSettingsDescription {
#[serde(rename = "AvailabilityZones")]
#[serde(skip_serializing_if = "Option::is_none")]
pub availability_zones: Option<Vec<String>>,
#[serde(rename = "ConnectIps")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connect_ips: Option<Vec<String>>,
#[serde(rename = "CustomerUserName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_user_name: Option<String>,
#[serde(rename = "SecurityGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_group_id: Option<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 DirectoryDescription {
#[serde(rename = "AccessUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_url: Option<String>,
#[serde(rename = "Alias")]
#[serde(skip_serializing_if = "Option::is_none")]
pub alias: Option<String>,
#[serde(rename = "ConnectSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connect_settings: Option<DirectoryConnectSettingsDescription>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DesiredNumberOfDomainControllers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub desired_number_of_domain_controllers: Option<i64>,
#[serde(rename = "DirectoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_id: Option<String>,
#[serde(rename = "DnsIpAddrs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dns_ip_addrs: Option<Vec<String>>,
#[serde(rename = "Edition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub edition: Option<String>,
#[serde(rename = "LaunchTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub launch_time: Option<f64>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "OwnerDirectoryDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner_directory_description: Option<OwnerDirectoryDescription>,
#[serde(rename = "RadiusSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub radius_settings: Option<RadiusSettings>,
#[serde(rename = "RadiusStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub radius_status: Option<String>,
#[serde(rename = "ShareMethod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub share_method: Option<String>,
#[serde(rename = "ShareNotes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub share_notes: Option<String>,
#[serde(rename = "ShareStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub share_status: Option<String>,
#[serde(rename = "ShortName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub short_name: Option<String>,
#[serde(rename = "Size")]
#[serde(skip_serializing_if = "Option::is_none")]
pub size: Option<String>,
#[serde(rename = "SsoEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sso_enabled: Option<bool>,
#[serde(rename = "Stage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stage: Option<String>,
#[serde(rename = "StageLastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stage_last_updated_date_time: Option<f64>,
#[serde(rename = "StageReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stage_reason: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "VpcSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_settings: Option<DirectoryVpcSettingsDescription>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DirectoryLimits {
#[serde(rename = "CloudOnlyDirectoriesCurrentCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_only_directories_current_count: Option<i64>,
#[serde(rename = "CloudOnlyDirectoriesLimit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_only_directories_limit: Option<i64>,
#[serde(rename = "CloudOnlyDirectoriesLimitReached")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_only_directories_limit_reached: Option<bool>,
#[serde(rename = "CloudOnlyMicrosoftADCurrentCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_only_microsoft_ad_current_count: Option<i64>,
#[serde(rename = "CloudOnlyMicrosoftADLimit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_only_microsoft_ad_limit: Option<i64>,
#[serde(rename = "CloudOnlyMicrosoftADLimitReached")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_only_microsoft_ad_limit_reached: Option<bool>,
#[serde(rename = "ConnectedDirectoriesCurrentCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connected_directories_current_count: Option<i64>,
#[serde(rename = "ConnectedDirectoriesLimit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connected_directories_limit: Option<i64>,
#[serde(rename = "ConnectedDirectoriesLimitReached")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connected_directories_limit_reached: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DirectoryVpcSettings {
#[serde(rename = "SubnetIds")]
pub subnet_ids: Vec<String>,
#[serde(rename = "VpcId")]
pub vpc_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DirectoryVpcSettingsDescription {
#[serde(rename = "AvailabilityZones")]
#[serde(skip_serializing_if = "Option::is_none")]
pub availability_zones: Option<Vec<String>>,
#[serde(rename = "SecurityGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_group_id: Option<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, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisableLDAPSRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "Type")]
pub type_: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisableLDAPSResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisableRadiusRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisableRadiusResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisableSsoRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "Password")]
#[serde(skip_serializing_if = "Option::is_none")]
pub password: Option<String>,
#[serde(rename = "UserName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisableSsoResult {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DomainController {
#[serde(rename = "AvailabilityZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub availability_zone: Option<String>,
#[serde(rename = "DirectoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_id: Option<String>,
#[serde(rename = "DnsIpAddr")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dns_ip_addr: Option<String>,
#[serde(rename = "DomainControllerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_controller_id: Option<String>,
#[serde(rename = "LaunchTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub launch_time: Option<f64>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "StatusLastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_last_updated_date_time: Option<f64>,
#[serde(rename = "StatusReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_reason: Option<String>,
#[serde(rename = "SubnetId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_id: Option<String>,
#[serde(rename = "VpcId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct EnableLDAPSRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "Type")]
pub type_: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EnableLDAPSResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct EnableRadiusRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "RadiusSettings")]
pub radius_settings: RadiusSettings,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EnableRadiusResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct EnableSsoRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "Password")]
#[serde(skip_serializing_if = "Option::is_none")]
pub password: Option<String>,
#[serde(rename = "UserName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EnableSsoResult {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EventTopic {
#[serde(rename = "CreatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_date_time: Option<f64>,
#[serde(rename = "DirectoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_id: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "TopicArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub topic_arn: Option<String>,
#[serde(rename = "TopicName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub topic_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDirectoryLimitsRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDirectoryLimitsResult {
#[serde(rename = "DirectoryLimits")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_limits: Option<DirectoryLimits>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetSnapshotLimitsRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetSnapshotLimitsResult {
#[serde(rename = "SnapshotLimits")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snapshot_limits: Option<SnapshotLimits>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct IpRoute {
#[serde(rename = "CidrIp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cidr_ip: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct IpRouteInfo {
#[serde(rename = "AddedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub added_date_time: Option<f64>,
#[serde(rename = "CidrIp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cidr_ip: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DirectoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_id: Option<String>,
#[serde(rename = "IpRouteStatusMsg")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_route_status_msg: Option<String>,
#[serde(rename = "IpRouteStatusReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_route_status_reason: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LDAPSSettingInfo {
#[serde(rename = "LDAPSStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ldaps_status: Option<String>,
#[serde(rename = "LDAPSStatusReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ldaps_status_reason: Option<String>,
#[serde(rename = "LastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date_time: Option<f64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListCertificatesRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: 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 ListCertificatesResult {
#[serde(rename = "CertificatesInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificates_info: Option<Vec<CertificateInfo>>,
#[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 ListIpRoutesRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: 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 ListIpRoutesResult {
#[serde(rename = "IpRoutesInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_routes_info: Option<Vec<IpRouteInfo>>,
#[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 ListLogSubscriptionsRequest {
#[serde(rename = "DirectoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_id: Option<String>,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: 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 ListLogSubscriptionsResult {
#[serde(rename = "LogSubscriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_subscriptions: Option<Vec<LogSubscription>>,
#[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 ListSchemaExtensionsRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: 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 ListSchemaExtensionsResult {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "SchemaExtensionsInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_extensions_info: Option<Vec<SchemaExtensionInfo>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceRequest {
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ResourceId")]
pub resource_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceResult {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LogSubscription {
#[serde(rename = "DirectoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_id: Option<String>,
#[serde(rename = "LogGroupName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_group_name: Option<String>,
#[serde(rename = "SubscriptionCreatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subscription_created_date_time: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct OwnerDirectoryDescription {
#[serde(rename = "AccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_id: Option<String>,
#[serde(rename = "DirectoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_id: Option<String>,
#[serde(rename = "DnsIpAddrs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dns_ip_addrs: Option<Vec<String>>,
#[serde(rename = "RadiusSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub radius_settings: Option<RadiusSettings>,
#[serde(rename = "RadiusStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub radius_status: Option<String>,
#[serde(rename = "VpcSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_settings: Option<DirectoryVpcSettingsDescription>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct RadiusSettings {
#[serde(rename = "AuthenticationProtocol")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authentication_protocol: Option<String>,
#[serde(rename = "DisplayLabel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_label: Option<String>,
#[serde(rename = "RadiusPort")]
#[serde(skip_serializing_if = "Option::is_none")]
pub radius_port: Option<i64>,
#[serde(rename = "RadiusRetries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub radius_retries: Option<i64>,
#[serde(rename = "RadiusServers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub radius_servers: Option<Vec<String>>,
#[serde(rename = "RadiusTimeout")]
#[serde(skip_serializing_if = "Option::is_none")]
pub radius_timeout: Option<i64>,
#[serde(rename = "SharedSecret")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shared_secret: Option<String>,
#[serde(rename = "UseSameUsername")]
#[serde(skip_serializing_if = "Option::is_none")]
pub use_same_username: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RegisterCertificateRequest {
#[serde(rename = "CertificateData")]
pub certificate_data: String,
#[serde(rename = "DirectoryId")]
pub directory_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RegisterCertificateResult {
#[serde(rename = "CertificateId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RegisterEventTopicRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "TopicName")]
pub topic_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RegisterEventTopicResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RejectSharedDirectoryRequest {
#[serde(rename = "SharedDirectoryId")]
pub shared_directory_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RejectSharedDirectoryResult {
#[serde(rename = "SharedDirectoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shared_directory_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RemoveIpRoutesRequest {
#[serde(rename = "CidrIps")]
pub cidr_ips: Vec<String>,
#[serde(rename = "DirectoryId")]
pub directory_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RemoveIpRoutesResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RemoveTagsFromResourceRequest {
#[serde(rename = "ResourceId")]
pub resource_id: 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 RemoveTagsFromResourceResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ResetUserPasswordRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "NewPassword")]
pub new_password: String,
#[serde(rename = "UserName")]
pub user_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResetUserPasswordResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RestoreFromSnapshotRequest {
#[serde(rename = "SnapshotId")]
pub snapshot_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RestoreFromSnapshotResult {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SchemaExtensionInfo {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DirectoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_id: Option<String>,
#[serde(rename = "EndDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_date_time: Option<f64>,
#[serde(rename = "SchemaExtensionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_extension_id: Option<String>,
#[serde(rename = "SchemaExtensionStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_extension_status: Option<String>,
#[serde(rename = "SchemaExtensionStatusReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_extension_status_reason: Option<String>,
#[serde(rename = "StartDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_date_time: Option<f64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ShareDirectoryRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "ShareMethod")]
pub share_method: String,
#[serde(rename = "ShareNotes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub share_notes: Option<String>,
#[serde(rename = "ShareTarget")]
pub share_target: ShareTarget,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ShareDirectoryResult {
#[serde(rename = "SharedDirectoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shared_directory_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ShareTarget {
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "Type")]
pub type_: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SharedDirectory {
#[serde(rename = "CreatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_date_time: Option<f64>,
#[serde(rename = "LastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date_time: Option<f64>,
#[serde(rename = "OwnerAccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner_account_id: Option<String>,
#[serde(rename = "OwnerDirectoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner_directory_id: Option<String>,
#[serde(rename = "ShareMethod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub share_method: Option<String>,
#[serde(rename = "ShareNotes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub share_notes: Option<String>,
#[serde(rename = "ShareStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub share_status: Option<String>,
#[serde(rename = "SharedAccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shared_account_id: Option<String>,
#[serde(rename = "SharedDirectoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shared_directory_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Snapshot {
#[serde(rename = "DirectoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "SnapshotId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snapshot_id: Option<String>,
#[serde(rename = "StartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SnapshotLimits {
#[serde(rename = "ManualSnapshotsCurrentCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub manual_snapshots_current_count: Option<i64>,
#[serde(rename = "ManualSnapshotsLimit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub manual_snapshots_limit: Option<i64>,
#[serde(rename = "ManualSnapshotsLimitReached")]
#[serde(skip_serializing_if = "Option::is_none")]
pub manual_snapshots_limit_reached: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartSchemaExtensionRequest {
#[serde(rename = "CreateSnapshotBeforeSchemaExtension")]
pub create_snapshot_before_schema_extension: bool,
#[serde(rename = "Description")]
pub description: String,
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "LdifContent")]
pub ldif_content: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartSchemaExtensionResult {
#[serde(rename = "SchemaExtensionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_extension_id: Option<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, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Trust {
#[serde(rename = "CreatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_date_time: Option<f64>,
#[serde(rename = "DirectoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_id: Option<String>,
#[serde(rename = "LastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date_time: Option<f64>,
#[serde(rename = "RemoteDomainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remote_domain_name: Option<String>,
#[serde(rename = "SelectiveAuth")]
#[serde(skip_serializing_if = "Option::is_none")]
pub selective_auth: Option<String>,
#[serde(rename = "StateLastUpdatedDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state_last_updated_date_time: Option<f64>,
#[serde(rename = "TrustDirection")]
#[serde(skip_serializing_if = "Option::is_none")]
pub trust_direction: Option<String>,
#[serde(rename = "TrustId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub trust_id: Option<String>,
#[serde(rename = "TrustState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub trust_state: Option<String>,
#[serde(rename = "TrustStateReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub trust_state_reason: Option<String>,
#[serde(rename = "TrustType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub trust_type: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UnshareDirectoryRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "UnshareTarget")]
pub unshare_target: UnshareTarget,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UnshareDirectoryResult {
#[serde(rename = "SharedDirectoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub shared_directory_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UnshareTarget {
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "Type")]
pub type_: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateConditionalForwarderRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "DnsIpAddrs")]
pub dns_ip_addrs: Vec<String>,
#[serde(rename = "RemoteDomainName")]
pub remote_domain_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateConditionalForwarderResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateNumberOfDomainControllersRequest {
#[serde(rename = "DesiredNumber")]
pub desired_number: i64,
#[serde(rename = "DirectoryId")]
pub directory_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateNumberOfDomainControllersResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateRadiusRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "RadiusSettings")]
pub radius_settings: RadiusSettings,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateRadiusResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateTrustRequest {
#[serde(rename = "SelectiveAuth")]
#[serde(skip_serializing_if = "Option::is_none")]
pub selective_auth: Option<String>,
#[serde(rename = "TrustId")]
pub trust_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateTrustResult {
#[serde(rename = "RequestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_id: Option<String>,
#[serde(rename = "TrustId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub trust_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct VerifyTrustRequest {
#[serde(rename = "TrustId")]
pub trust_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct VerifyTrustResult {
#[serde(rename = "TrustId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub trust_id: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum AcceptSharedDirectoryError {
Client(String),
DirectoryAlreadyShared(String),
EntityDoesNotExist(String),
InvalidParameter(String),
Service(String),
}
impl AcceptSharedDirectoryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AcceptSharedDirectoryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(AcceptSharedDirectoryError::Client(err.msg))
}
"DirectoryAlreadySharedException" => {
return RusotoError::Service(
AcceptSharedDirectoryError::DirectoryAlreadyShared(err.msg),
)
}
"EntityDoesNotExistException" => {
return RusotoError::Service(AcceptSharedDirectoryError::EntityDoesNotExist(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(AcceptSharedDirectoryError::InvalidParameter(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(AcceptSharedDirectoryError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AcceptSharedDirectoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AcceptSharedDirectoryError::Client(ref cause) => write!(f, "{}", cause),
AcceptSharedDirectoryError::DirectoryAlreadyShared(ref cause) => write!(f, "{}", cause),
AcceptSharedDirectoryError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
AcceptSharedDirectoryError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AcceptSharedDirectoryError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AcceptSharedDirectoryError {}
#[derive(Debug, PartialEq)]
pub enum AddIpRoutesError {
Client(String),
DirectoryUnavailable(String),
EntityAlreadyExists(String),
EntityDoesNotExist(String),
InvalidParameter(String),
IpRouteLimitExceeded(String),
Service(String),
}
impl AddIpRoutesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AddIpRoutesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(AddIpRoutesError::Client(err.msg))
}
"DirectoryUnavailableException" => {
return RusotoError::Service(AddIpRoutesError::DirectoryUnavailable(err.msg))
}
"EntityAlreadyExistsException" => {
return RusotoError::Service(AddIpRoutesError::EntityAlreadyExists(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(AddIpRoutesError::EntityDoesNotExist(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(AddIpRoutesError::InvalidParameter(err.msg))
}
"IpRouteLimitExceededException" => {
return RusotoError::Service(AddIpRoutesError::IpRouteLimitExceeded(err.msg))
}
"ServiceException" => {
return RusotoError::Service(AddIpRoutesError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AddIpRoutesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AddIpRoutesError::Client(ref cause) => write!(f, "{}", cause),
AddIpRoutesError::DirectoryUnavailable(ref cause) => write!(f, "{}", cause),
AddIpRoutesError::EntityAlreadyExists(ref cause) => write!(f, "{}", cause),
AddIpRoutesError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
AddIpRoutesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AddIpRoutesError::IpRouteLimitExceeded(ref cause) => write!(f, "{}", cause),
AddIpRoutesError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AddIpRoutesError {}
#[derive(Debug, PartialEq)]
pub enum AddTagsToResourceError {
Client(String),
EntityDoesNotExist(String),
InvalidParameter(String),
Service(String),
TagLimitExceeded(String),
}
impl AddTagsToResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AddTagsToResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(AddTagsToResourceError::Client(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(AddTagsToResourceError::EntityDoesNotExist(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(AddTagsToResourceError::InvalidParameter(err.msg))
}
"ServiceException" => {
return RusotoError::Service(AddTagsToResourceError::Service(err.msg))
}
"TagLimitExceededException" => {
return RusotoError::Service(AddTagsToResourceError::TagLimitExceeded(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AddTagsToResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AddTagsToResourceError::Client(ref cause) => write!(f, "{}", cause),
AddTagsToResourceError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
AddTagsToResourceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AddTagsToResourceError::Service(ref cause) => write!(f, "{}", cause),
AddTagsToResourceError::TagLimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AddTagsToResourceError {}
#[derive(Debug, PartialEq)]
pub enum CancelSchemaExtensionError {
Client(String),
EntityDoesNotExist(String),
Service(String),
}
impl CancelSchemaExtensionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CancelSchemaExtensionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(CancelSchemaExtensionError::Client(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(CancelSchemaExtensionError::EntityDoesNotExist(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(CancelSchemaExtensionError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CancelSchemaExtensionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CancelSchemaExtensionError::Client(ref cause) => write!(f, "{}", cause),
CancelSchemaExtensionError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
CancelSchemaExtensionError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CancelSchemaExtensionError {}
#[derive(Debug, PartialEq)]
pub enum ConnectDirectoryError {
Client(String),
DirectoryLimitExceeded(String),
InvalidParameter(String),
Service(String),
}
impl ConnectDirectoryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ConnectDirectoryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(ConnectDirectoryError::Client(err.msg))
}
"DirectoryLimitExceededException" => {
return RusotoError::Service(ConnectDirectoryError::DirectoryLimitExceeded(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(ConnectDirectoryError::InvalidParameter(err.msg))
}
"ServiceException" => {
return RusotoError::Service(ConnectDirectoryError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ConnectDirectoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ConnectDirectoryError::Client(ref cause) => write!(f, "{}", cause),
ConnectDirectoryError::DirectoryLimitExceeded(ref cause) => write!(f, "{}", cause),
ConnectDirectoryError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ConnectDirectoryError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ConnectDirectoryError {}
#[derive(Debug, PartialEq)]
pub enum CreateAliasError {
Client(String),
EntityAlreadyExists(String),
EntityDoesNotExist(String),
InvalidParameter(String),
Service(String),
}
impl CreateAliasError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateAliasError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(CreateAliasError::Client(err.msg))
}
"EntityAlreadyExistsException" => {
return RusotoError::Service(CreateAliasError::EntityAlreadyExists(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(CreateAliasError::EntityDoesNotExist(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateAliasError::InvalidParameter(err.msg))
}
"ServiceException" => {
return RusotoError::Service(CreateAliasError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateAliasError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateAliasError::Client(ref cause) => write!(f, "{}", cause),
CreateAliasError::EntityAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateAliasError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
CreateAliasError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateAliasError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateAliasError {}
#[derive(Debug, PartialEq)]
pub enum CreateComputerError {
AuthenticationFailed(String),
Client(String),
DirectoryUnavailable(String),
EntityAlreadyExists(String),
EntityDoesNotExist(String),
InvalidParameter(String),
Service(String),
UnsupportedOperation(String),
}
impl CreateComputerError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateComputerError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthenticationFailedException" => {
return RusotoError::Service(CreateComputerError::AuthenticationFailed(err.msg))
}
"ClientException" => {
return RusotoError::Service(CreateComputerError::Client(err.msg))
}
"DirectoryUnavailableException" => {
return RusotoError::Service(CreateComputerError::DirectoryUnavailable(err.msg))
}
"EntityAlreadyExistsException" => {
return RusotoError::Service(CreateComputerError::EntityAlreadyExists(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(CreateComputerError::EntityDoesNotExist(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateComputerError::InvalidParameter(err.msg))
}
"ServiceException" => {
return RusotoError::Service(CreateComputerError::Service(err.msg))
}
"UnsupportedOperationException" => {
return RusotoError::Service(CreateComputerError::UnsupportedOperation(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateComputerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateComputerError::AuthenticationFailed(ref cause) => write!(f, "{}", cause),
CreateComputerError::Client(ref cause) => write!(f, "{}", cause),
CreateComputerError::DirectoryUnavailable(ref cause) => write!(f, "{}", cause),
CreateComputerError::EntityAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateComputerError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
CreateComputerError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateComputerError::Service(ref cause) => write!(f, "{}", cause),
CreateComputerError::UnsupportedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateComputerError {}
#[derive(Debug, PartialEq)]
pub enum CreateConditionalForwarderError {
Client(String),
DirectoryUnavailable(String),
EntityAlreadyExists(String),
EntityDoesNotExist(String),
InvalidParameter(String),
Service(String),
UnsupportedOperation(String),
}
impl CreateConditionalForwarderError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateConditionalForwarderError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(CreateConditionalForwarderError::Client(err.msg))
}
"DirectoryUnavailableException" => {
return RusotoError::Service(
CreateConditionalForwarderError::DirectoryUnavailable(err.msg),
)
}
"EntityAlreadyExistsException" => {
return RusotoError::Service(
CreateConditionalForwarderError::EntityAlreadyExists(err.msg),
)
}
"EntityDoesNotExistException" => {
return RusotoError::Service(
CreateConditionalForwarderError::EntityDoesNotExist(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(CreateConditionalForwarderError::InvalidParameter(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(CreateConditionalForwarderError::Service(err.msg))
}
"UnsupportedOperationException" => {
return RusotoError::Service(
CreateConditionalForwarderError::UnsupportedOperation(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateConditionalForwarderError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateConditionalForwarderError::Client(ref cause) => write!(f, "{}", cause),
CreateConditionalForwarderError::DirectoryUnavailable(ref cause) => {
write!(f, "{}", cause)
}
CreateConditionalForwarderError::EntityAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
CreateConditionalForwarderError::EntityDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
CreateConditionalForwarderError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateConditionalForwarderError::Service(ref cause) => write!(f, "{}", cause),
CreateConditionalForwarderError::UnsupportedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateConditionalForwarderError {}
#[derive(Debug, PartialEq)]
pub enum CreateDirectoryError {
Client(String),
DirectoryLimitExceeded(String),
InvalidParameter(String),
Service(String),
}
impl CreateDirectoryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDirectoryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(CreateDirectoryError::Client(err.msg))
}
"DirectoryLimitExceededException" => {
return RusotoError::Service(CreateDirectoryError::DirectoryLimitExceeded(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateDirectoryError::InvalidParameter(err.msg))
}
"ServiceException" => {
return RusotoError::Service(CreateDirectoryError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDirectoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDirectoryError::Client(ref cause) => write!(f, "{}", cause),
CreateDirectoryError::DirectoryLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateDirectoryError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateDirectoryError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDirectoryError {}
#[derive(Debug, PartialEq)]
pub enum CreateLogSubscriptionError {
Client(String),
EntityAlreadyExists(String),
EntityDoesNotExist(String),
InsufficientPermissions(String),
Service(String),
UnsupportedOperation(String),
}
impl CreateLogSubscriptionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateLogSubscriptionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(CreateLogSubscriptionError::Client(err.msg))
}
"EntityAlreadyExistsException" => {
return RusotoError::Service(CreateLogSubscriptionError::EntityAlreadyExists(
err.msg,
))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(CreateLogSubscriptionError::EntityDoesNotExist(
err.msg,
))
}
"InsufficientPermissionsException" => {
return RusotoError::Service(
CreateLogSubscriptionError::InsufficientPermissions(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(CreateLogSubscriptionError::Service(err.msg))
}
"UnsupportedOperationException" => {
return RusotoError::Service(CreateLogSubscriptionError::UnsupportedOperation(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateLogSubscriptionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateLogSubscriptionError::Client(ref cause) => write!(f, "{}", cause),
CreateLogSubscriptionError::EntityAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateLogSubscriptionError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
CreateLogSubscriptionError::InsufficientPermissions(ref cause) => {
write!(f, "{}", cause)
}
CreateLogSubscriptionError::Service(ref cause) => write!(f, "{}", cause),
CreateLogSubscriptionError::UnsupportedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateLogSubscriptionError {}
#[derive(Debug, PartialEq)]
pub enum CreateMicrosoftADError {
Client(String),
DirectoryLimitExceeded(String),
InvalidParameter(String),
Service(String),
UnsupportedOperation(String),
}
impl CreateMicrosoftADError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateMicrosoftADError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(CreateMicrosoftADError::Client(err.msg))
}
"DirectoryLimitExceededException" => {
return RusotoError::Service(CreateMicrosoftADError::DirectoryLimitExceeded(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateMicrosoftADError::InvalidParameter(err.msg))
}
"ServiceException" => {
return RusotoError::Service(CreateMicrosoftADError::Service(err.msg))
}
"UnsupportedOperationException" => {
return RusotoError::Service(CreateMicrosoftADError::UnsupportedOperation(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateMicrosoftADError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateMicrosoftADError::Client(ref cause) => write!(f, "{}", cause),
CreateMicrosoftADError::DirectoryLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateMicrosoftADError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateMicrosoftADError::Service(ref cause) => write!(f, "{}", cause),
CreateMicrosoftADError::UnsupportedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateMicrosoftADError {}
#[derive(Debug, PartialEq)]
pub enum CreateSnapshotError {
Client(String),
EntityDoesNotExist(String),
InvalidParameter(String),
Service(String),
SnapshotLimitExceeded(String),
}
impl CreateSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateSnapshotError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(CreateSnapshotError::Client(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(CreateSnapshotError::EntityDoesNotExist(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateSnapshotError::InvalidParameter(err.msg))
}
"ServiceException" => {
return RusotoError::Service(CreateSnapshotError::Service(err.msg))
}
"SnapshotLimitExceededException" => {
return RusotoError::Service(CreateSnapshotError::SnapshotLimitExceeded(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateSnapshotError::Client(ref cause) => write!(f, "{}", cause),
CreateSnapshotError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
CreateSnapshotError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateSnapshotError::Service(ref cause) => write!(f, "{}", cause),
CreateSnapshotError::SnapshotLimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum CreateTrustError {
Client(String),
EntityAlreadyExists(String),
EntityDoesNotExist(String),
InvalidParameter(String),
Service(String),
UnsupportedOperation(String),
}
impl CreateTrustError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateTrustError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(CreateTrustError::Client(err.msg))
}
"EntityAlreadyExistsException" => {
return RusotoError::Service(CreateTrustError::EntityAlreadyExists(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(CreateTrustError::EntityDoesNotExist(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateTrustError::InvalidParameter(err.msg))
}
"ServiceException" => {
return RusotoError::Service(CreateTrustError::Service(err.msg))
}
"UnsupportedOperationException" => {
return RusotoError::Service(CreateTrustError::UnsupportedOperation(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateTrustError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateTrustError::Client(ref cause) => write!(f, "{}", cause),
CreateTrustError::EntityAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateTrustError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
CreateTrustError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateTrustError::Service(ref cause) => write!(f, "{}", cause),
CreateTrustError::UnsupportedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateTrustError {}
#[derive(Debug, PartialEq)]
pub enum DeleteConditionalForwarderError {
Client(String),
DirectoryUnavailable(String),
EntityDoesNotExist(String),
InvalidParameter(String),
Service(String),
UnsupportedOperation(String),
}
impl DeleteConditionalForwarderError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteConditionalForwarderError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(DeleteConditionalForwarderError::Client(err.msg))
}
"DirectoryUnavailableException" => {
return RusotoError::Service(
DeleteConditionalForwarderError::DirectoryUnavailable(err.msg),
)
}
"EntityDoesNotExistException" => {
return RusotoError::Service(
DeleteConditionalForwarderError::EntityDoesNotExist(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(DeleteConditionalForwarderError::InvalidParameter(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(DeleteConditionalForwarderError::Service(err.msg))
}
"UnsupportedOperationException" => {
return RusotoError::Service(
DeleteConditionalForwarderError::UnsupportedOperation(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteConditionalForwarderError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteConditionalForwarderError::Client(ref cause) => write!(f, "{}", cause),
DeleteConditionalForwarderError::DirectoryUnavailable(ref cause) => {
write!(f, "{}", cause)
}
DeleteConditionalForwarderError::EntityDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
DeleteConditionalForwarderError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteConditionalForwarderError::Service(ref cause) => write!(f, "{}", cause),
DeleteConditionalForwarderError::UnsupportedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteConditionalForwarderError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDirectoryError {
Client(String),
EntityDoesNotExist(String),
Service(String),
}
impl DeleteDirectoryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDirectoryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(DeleteDirectoryError::Client(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(DeleteDirectoryError::EntityDoesNotExist(err.msg))
}
"ServiceException" => {
return RusotoError::Service(DeleteDirectoryError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDirectoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDirectoryError::Client(ref cause) => write!(f, "{}", cause),
DeleteDirectoryError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
DeleteDirectoryError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDirectoryError {}
#[derive(Debug, PartialEq)]
pub enum DeleteLogSubscriptionError {
Client(String),
EntityDoesNotExist(String),
Service(String),
UnsupportedOperation(String),
}
impl DeleteLogSubscriptionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteLogSubscriptionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(DeleteLogSubscriptionError::Client(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(DeleteLogSubscriptionError::EntityDoesNotExist(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(DeleteLogSubscriptionError::Service(err.msg))
}
"UnsupportedOperationException" => {
return RusotoError::Service(DeleteLogSubscriptionError::UnsupportedOperation(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteLogSubscriptionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteLogSubscriptionError::Client(ref cause) => write!(f, "{}", cause),
DeleteLogSubscriptionError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
DeleteLogSubscriptionError::Service(ref cause) => write!(f, "{}", cause),
DeleteLogSubscriptionError::UnsupportedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteLogSubscriptionError {}
#[derive(Debug, PartialEq)]
pub enum DeleteSnapshotError {
Client(String),
EntityDoesNotExist(String),
InvalidParameter(String),
Service(String),
}
impl DeleteSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteSnapshotError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(DeleteSnapshotError::Client(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(DeleteSnapshotError::EntityDoesNotExist(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DeleteSnapshotError::InvalidParameter(err.msg))
}
"ServiceException" => {
return RusotoError::Service(DeleteSnapshotError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteSnapshotError::Client(ref cause) => write!(f, "{}", cause),
DeleteSnapshotError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
DeleteSnapshotError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteSnapshotError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum DeleteTrustError {
Client(String),
EntityDoesNotExist(String),
InvalidParameter(String),
Service(String),
UnsupportedOperation(String),
}
impl DeleteTrustError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteTrustError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(DeleteTrustError::Client(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(DeleteTrustError::EntityDoesNotExist(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DeleteTrustError::InvalidParameter(err.msg))
}
"ServiceException" => {
return RusotoError::Service(DeleteTrustError::Service(err.msg))
}
"UnsupportedOperationException" => {
return RusotoError::Service(DeleteTrustError::UnsupportedOperation(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteTrustError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteTrustError::Client(ref cause) => write!(f, "{}", cause),
DeleteTrustError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
DeleteTrustError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteTrustError::Service(ref cause) => write!(f, "{}", cause),
DeleteTrustError::UnsupportedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteTrustError {}
#[derive(Debug, PartialEq)]
pub enum DeregisterCertificateError {
CertificateDoesNotExist(String),
CertificateInUse(String),
Client(String),
DirectoryDoesNotExist(String),
DirectoryUnavailable(String),
InvalidParameter(String),
Service(String),
UnsupportedOperation(String),
}
impl DeregisterCertificateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeregisterCertificateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CertificateDoesNotExistException" => {
return RusotoError::Service(
DeregisterCertificateError::CertificateDoesNotExist(err.msg),
)
}
"CertificateInUseException" => {
return RusotoError::Service(DeregisterCertificateError::CertificateInUse(
err.msg,
))
}
"ClientException" => {
return RusotoError::Service(DeregisterCertificateError::Client(err.msg))
}
"DirectoryDoesNotExistException" => {
return RusotoError::Service(DeregisterCertificateError::DirectoryDoesNotExist(
err.msg,
))
}
"DirectoryUnavailableException" => {
return RusotoError::Service(DeregisterCertificateError::DirectoryUnavailable(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DeregisterCertificateError::InvalidParameter(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(DeregisterCertificateError::Service(err.msg))
}
"UnsupportedOperationException" => {
return RusotoError::Service(DeregisterCertificateError::UnsupportedOperation(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeregisterCertificateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeregisterCertificateError::CertificateDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
DeregisterCertificateError::CertificateInUse(ref cause) => write!(f, "{}", cause),
DeregisterCertificateError::Client(ref cause) => write!(f, "{}", cause),
DeregisterCertificateError::DirectoryDoesNotExist(ref cause) => write!(f, "{}", cause),
DeregisterCertificateError::DirectoryUnavailable(ref cause) => write!(f, "{}", cause),
DeregisterCertificateError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeregisterCertificateError::Service(ref cause) => write!(f, "{}", cause),
DeregisterCertificateError::UnsupportedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeregisterCertificateError {}
#[derive(Debug, PartialEq)]
pub enum DeregisterEventTopicError {
Client(String),
EntityDoesNotExist(String),
InvalidParameter(String),
Service(String),
}
impl DeregisterEventTopicError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeregisterEventTopicError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(DeregisterEventTopicError::Client(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(DeregisterEventTopicError::EntityDoesNotExist(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DeregisterEventTopicError::InvalidParameter(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(DeregisterEventTopicError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeregisterEventTopicError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeregisterEventTopicError::Client(ref cause) => write!(f, "{}", cause),
DeregisterEventTopicError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
DeregisterEventTopicError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeregisterEventTopicError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeregisterEventTopicError {}
#[derive(Debug, PartialEq)]
pub enum DescribeCertificateError {
CertificateDoesNotExist(String),
Client(String),
DirectoryDoesNotExist(String),
InvalidParameter(String),
Service(String),
UnsupportedOperation(String),
}
impl DescribeCertificateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeCertificateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CertificateDoesNotExistException" => {
return RusotoError::Service(DescribeCertificateError::CertificateDoesNotExist(
err.msg,
))
}
"ClientException" => {
return RusotoError::Service(DescribeCertificateError::Client(err.msg))
}
"DirectoryDoesNotExistException" => {
return RusotoError::Service(DescribeCertificateError::DirectoryDoesNotExist(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeCertificateError::InvalidParameter(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(DescribeCertificateError::Service(err.msg))
}
"UnsupportedOperationException" => {
return RusotoError::Service(DescribeCertificateError::UnsupportedOperation(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeCertificateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeCertificateError::CertificateDoesNotExist(ref cause) => write!(f, "{}", cause),
DescribeCertificateError::Client(ref cause) => write!(f, "{}", cause),
DescribeCertificateError::DirectoryDoesNotExist(ref cause) => write!(f, "{}", cause),
DescribeCertificateError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeCertificateError::Service(ref cause) => write!(f, "{}", cause),
DescribeCertificateError::UnsupportedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeCertificateError {}
#[derive(Debug, PartialEq)]
pub enum DescribeConditionalForwardersError {
Client(String),
DirectoryUnavailable(String),
EntityDoesNotExist(String),
InvalidParameter(String),
Service(String),
UnsupportedOperation(String),
}
impl DescribeConditionalForwardersError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeConditionalForwardersError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(DescribeConditionalForwardersError::Client(
err.msg,
))
}
"DirectoryUnavailableException" => {
return RusotoError::Service(
DescribeConditionalForwardersError::DirectoryUnavailable(err.msg),
)
}
"EntityDoesNotExistException" => {
return RusotoError::Service(
DescribeConditionalForwardersError::EntityDoesNotExist(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(
DescribeConditionalForwardersError::InvalidParameter(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(DescribeConditionalForwardersError::Service(
err.msg,
))
}
"UnsupportedOperationException" => {
return RusotoError::Service(
DescribeConditionalForwardersError::UnsupportedOperation(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeConditionalForwardersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeConditionalForwardersError::Client(ref cause) => write!(f, "{}", cause),
DescribeConditionalForwardersError::DirectoryUnavailable(ref cause) => {
write!(f, "{}", cause)
}
DescribeConditionalForwardersError::EntityDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
DescribeConditionalForwardersError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
DescribeConditionalForwardersError::Service(ref cause) => write!(f, "{}", cause),
DescribeConditionalForwardersError::UnsupportedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeConditionalForwardersError {}
#[derive(Debug, PartialEq)]
pub enum DescribeDirectoriesError {
Client(String),
EntityDoesNotExist(String),
InvalidNextToken(String),
InvalidParameter(String),
Service(String),
}
impl DescribeDirectoriesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeDirectoriesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(DescribeDirectoriesError::Client(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(DescribeDirectoriesError::EntityDoesNotExist(
err.msg,
))
}
"InvalidNextTokenException" => {
return RusotoError::Service(DescribeDirectoriesError::InvalidNextToken(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeDirectoriesError::InvalidParameter(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(DescribeDirectoriesError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeDirectoriesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeDirectoriesError::Client(ref cause) => write!(f, "{}", cause),
DescribeDirectoriesError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
DescribeDirectoriesError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
DescribeDirectoriesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeDirectoriesError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeDirectoriesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeDomainControllersError {
Client(String),
EntityDoesNotExist(String),
InvalidNextToken(String),
InvalidParameter(String),
Service(String),
UnsupportedOperation(String),
}
impl DescribeDomainControllersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeDomainControllersError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(DescribeDomainControllersError::Client(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(
DescribeDomainControllersError::EntityDoesNotExist(err.msg),
)
}
"InvalidNextTokenException" => {
return RusotoError::Service(DescribeDomainControllersError::InvalidNextToken(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeDomainControllersError::InvalidParameter(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(DescribeDomainControllersError::Service(err.msg))
}
"UnsupportedOperationException" => {
return RusotoError::Service(
DescribeDomainControllersError::UnsupportedOperation(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeDomainControllersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeDomainControllersError::Client(ref cause) => write!(f, "{}", cause),
DescribeDomainControllersError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
DescribeDomainControllersError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
DescribeDomainControllersError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeDomainControllersError::Service(ref cause) => write!(f, "{}", cause),
DescribeDomainControllersError::UnsupportedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeDomainControllersError {}
#[derive(Debug, PartialEq)]
pub enum DescribeEventTopicsError {
Client(String),
EntityDoesNotExist(String),
InvalidParameter(String),
Service(String),
}
impl DescribeEventTopicsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeEventTopicsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(DescribeEventTopicsError::Client(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(DescribeEventTopicsError::EntityDoesNotExist(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeEventTopicsError::InvalidParameter(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(DescribeEventTopicsError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeEventTopicsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeEventTopicsError::Client(ref cause) => write!(f, "{}", cause),
DescribeEventTopicsError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
DescribeEventTopicsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeEventTopicsError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeEventTopicsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeLDAPSSettingsError {
Client(String),
DirectoryDoesNotExist(String),
InvalidNextToken(String),
InvalidParameter(String),
Service(String),
UnsupportedOperation(String),
}
impl DescribeLDAPSSettingsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeLDAPSSettingsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(DescribeLDAPSSettingsError::Client(err.msg))
}
"DirectoryDoesNotExistException" => {
return RusotoError::Service(DescribeLDAPSSettingsError::DirectoryDoesNotExist(
err.msg,
))
}
"InvalidNextTokenException" => {
return RusotoError::Service(DescribeLDAPSSettingsError::InvalidNextToken(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeLDAPSSettingsError::InvalidParameter(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(DescribeLDAPSSettingsError::Service(err.msg))
}
"UnsupportedOperationException" => {
return RusotoError::Service(DescribeLDAPSSettingsError::UnsupportedOperation(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeLDAPSSettingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeLDAPSSettingsError::Client(ref cause) => write!(f, "{}", cause),
DescribeLDAPSSettingsError::DirectoryDoesNotExist(ref cause) => write!(f, "{}", cause),
DescribeLDAPSSettingsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
DescribeLDAPSSettingsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeLDAPSSettingsError::Service(ref cause) => write!(f, "{}", cause),
DescribeLDAPSSettingsError::UnsupportedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeLDAPSSettingsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeSharedDirectoriesError {
Client(String),
EntityDoesNotExist(String),
InvalidNextToken(String),
InvalidParameter(String),
Service(String),
UnsupportedOperation(String),
}
impl DescribeSharedDirectoriesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeSharedDirectoriesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(DescribeSharedDirectoriesError::Client(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(
DescribeSharedDirectoriesError::EntityDoesNotExist(err.msg),
)
}
"InvalidNextTokenException" => {
return RusotoError::Service(DescribeSharedDirectoriesError::InvalidNextToken(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeSharedDirectoriesError::InvalidParameter(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(DescribeSharedDirectoriesError::Service(err.msg))
}
"UnsupportedOperationException" => {
return RusotoError::Service(
DescribeSharedDirectoriesError::UnsupportedOperation(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeSharedDirectoriesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeSharedDirectoriesError::Client(ref cause) => write!(f, "{}", cause),
DescribeSharedDirectoriesError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
DescribeSharedDirectoriesError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
DescribeSharedDirectoriesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeSharedDirectoriesError::Service(ref cause) => write!(f, "{}", cause),
DescribeSharedDirectoriesError::UnsupportedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeSharedDirectoriesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeSnapshotsError {
Client(String),
EntityDoesNotExist(String),
InvalidNextToken(String),
InvalidParameter(String),
Service(String),
}
impl DescribeSnapshotsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeSnapshotsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(DescribeSnapshotsError::Client(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(DescribeSnapshotsError::EntityDoesNotExist(
err.msg,
))
}
"InvalidNextTokenException" => {
return RusotoError::Service(DescribeSnapshotsError::InvalidNextToken(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeSnapshotsError::InvalidParameter(err.msg))
}
"ServiceException" => {
return RusotoError::Service(DescribeSnapshotsError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeSnapshotsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeSnapshotsError::Client(ref cause) => write!(f, "{}", cause),
DescribeSnapshotsError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
DescribeSnapshotsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
DescribeSnapshotsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeSnapshotsError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeSnapshotsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeTrustsError {
Client(String),
EntityDoesNotExist(String),
InvalidNextToken(String),
InvalidParameter(String),
Service(String),
UnsupportedOperation(String),
}
impl DescribeTrustsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeTrustsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(DescribeTrustsError::Client(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(DescribeTrustsError::EntityDoesNotExist(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(DescribeTrustsError::InvalidNextToken(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeTrustsError::InvalidParameter(err.msg))
}
"ServiceException" => {
return RusotoError::Service(DescribeTrustsError::Service(err.msg))
}
"UnsupportedOperationException" => {
return RusotoError::Service(DescribeTrustsError::UnsupportedOperation(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeTrustsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeTrustsError::Client(ref cause) => write!(f, "{}", cause),
DescribeTrustsError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
DescribeTrustsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
DescribeTrustsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeTrustsError::Service(ref cause) => write!(f, "{}", cause),
DescribeTrustsError::UnsupportedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeTrustsError {}
#[derive(Debug, PartialEq)]
pub enum DisableLDAPSError {
Client(String),
DirectoryDoesNotExist(String),
DirectoryUnavailable(String),
InvalidLDAPSStatus(String),
InvalidParameter(String),
Service(String),
UnsupportedOperation(String),
}
impl DisableLDAPSError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DisableLDAPSError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(DisableLDAPSError::Client(err.msg))
}
"DirectoryDoesNotExistException" => {
return RusotoError::Service(DisableLDAPSError::DirectoryDoesNotExist(err.msg))
}
"DirectoryUnavailableException" => {
return RusotoError::Service(DisableLDAPSError::DirectoryUnavailable(err.msg))
}
"InvalidLDAPSStatusException" => {
return RusotoError::Service(DisableLDAPSError::InvalidLDAPSStatus(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DisableLDAPSError::InvalidParameter(err.msg))
}
"ServiceException" => {
return RusotoError::Service(DisableLDAPSError::Service(err.msg))
}
"UnsupportedOperationException" => {
return RusotoError::Service(DisableLDAPSError::UnsupportedOperation(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisableLDAPSError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisableLDAPSError::Client(ref cause) => write!(f, "{}", cause),
DisableLDAPSError::DirectoryDoesNotExist(ref cause) => write!(f, "{}", cause),
DisableLDAPSError::DirectoryUnavailable(ref cause) => write!(f, "{}", cause),
DisableLDAPSError::InvalidLDAPSStatus(ref cause) => write!(f, "{}", cause),
DisableLDAPSError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DisableLDAPSError::Service(ref cause) => write!(f, "{}", cause),
DisableLDAPSError::UnsupportedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DisableLDAPSError {}
#[derive(Debug, PartialEq)]
pub enum DisableRadiusError {
Client(String),
EntityDoesNotExist(String),
Service(String),
}
impl DisableRadiusError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DisableRadiusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(DisableRadiusError::Client(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(DisableRadiusError::EntityDoesNotExist(err.msg))
}
"ServiceException" => {
return RusotoError::Service(DisableRadiusError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisableRadiusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisableRadiusError::Client(ref cause) => write!(f, "{}", cause),
DisableRadiusError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
DisableRadiusError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DisableRadiusError {}
#[derive(Debug, PartialEq)]
pub enum DisableSsoError {
AuthenticationFailed(String),
Client(String),
EntityDoesNotExist(String),
InsufficientPermissions(String),
Service(String),
}
impl DisableSsoError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DisableSsoError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthenticationFailedException" => {
return RusotoError::Service(DisableSsoError::AuthenticationFailed(err.msg))
}
"ClientException" => return RusotoError::Service(DisableSsoError::Client(err.msg)),
"EntityDoesNotExistException" => {
return RusotoError::Service(DisableSsoError::EntityDoesNotExist(err.msg))
}
"InsufficientPermissionsException" => {
return RusotoError::Service(DisableSsoError::InsufficientPermissions(err.msg))
}
"ServiceException" => {
return RusotoError::Service(DisableSsoError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisableSsoError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisableSsoError::AuthenticationFailed(ref cause) => write!(f, "{}", cause),
DisableSsoError::Client(ref cause) => write!(f, "{}", cause),
DisableSsoError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
DisableSsoError::InsufficientPermissions(ref cause) => write!(f, "{}", cause),
DisableSsoError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DisableSsoError {}
#[derive(Debug, PartialEq)]
pub enum EnableLDAPSError {
Client(String),
DirectoryDoesNotExist(String),
DirectoryUnavailable(String),
InvalidLDAPSStatus(String),
InvalidParameter(String),
NoAvailableCertificate(String),
Service(String),
UnsupportedOperation(String),
}
impl EnableLDAPSError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<EnableLDAPSError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(EnableLDAPSError::Client(err.msg))
}
"DirectoryDoesNotExistException" => {
return RusotoError::Service(EnableLDAPSError::DirectoryDoesNotExist(err.msg))
}
"DirectoryUnavailableException" => {
return RusotoError::Service(EnableLDAPSError::DirectoryUnavailable(err.msg))
}
"InvalidLDAPSStatusException" => {
return RusotoError::Service(EnableLDAPSError::InvalidLDAPSStatus(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(EnableLDAPSError::InvalidParameter(err.msg))
}
"NoAvailableCertificateException" => {
return RusotoError::Service(EnableLDAPSError::NoAvailableCertificate(err.msg))
}
"ServiceException" => {
return RusotoError::Service(EnableLDAPSError::Service(err.msg))
}
"UnsupportedOperationException" => {
return RusotoError::Service(EnableLDAPSError::UnsupportedOperation(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for EnableLDAPSError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
EnableLDAPSError::Client(ref cause) => write!(f, "{}", cause),
EnableLDAPSError::DirectoryDoesNotExist(ref cause) => write!(f, "{}", cause),
EnableLDAPSError::DirectoryUnavailable(ref cause) => write!(f, "{}", cause),
EnableLDAPSError::InvalidLDAPSStatus(ref cause) => write!(f, "{}", cause),
EnableLDAPSError::InvalidParameter(ref cause) => write!(f, "{}", cause),
EnableLDAPSError::NoAvailableCertificate(ref cause) => write!(f, "{}", cause),
EnableLDAPSError::Service(ref cause) => write!(f, "{}", cause),
EnableLDAPSError::UnsupportedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for EnableLDAPSError {}
#[derive(Debug, PartialEq)]
pub enum EnableRadiusError {
Client(String),
EntityAlreadyExists(String),
EntityDoesNotExist(String),
InvalidParameter(String),
Service(String),
}
impl EnableRadiusError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<EnableRadiusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(EnableRadiusError::Client(err.msg))
}
"EntityAlreadyExistsException" => {
return RusotoError::Service(EnableRadiusError::EntityAlreadyExists(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(EnableRadiusError::EntityDoesNotExist(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(EnableRadiusError::InvalidParameter(err.msg))
}
"ServiceException" => {
return RusotoError::Service(EnableRadiusError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for EnableRadiusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
EnableRadiusError::Client(ref cause) => write!(f, "{}", cause),
EnableRadiusError::EntityAlreadyExists(ref cause) => write!(f, "{}", cause),
EnableRadiusError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
EnableRadiusError::InvalidParameter(ref cause) => write!(f, "{}", cause),
EnableRadiusError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for EnableRadiusError {}
#[derive(Debug, PartialEq)]
pub enum EnableSsoError {
AuthenticationFailed(String),
Client(String),
EntityDoesNotExist(String),
InsufficientPermissions(String),
Service(String),
}
impl EnableSsoError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<EnableSsoError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthenticationFailedException" => {
return RusotoError::Service(EnableSsoError::AuthenticationFailed(err.msg))
}
"ClientException" => return RusotoError::Service(EnableSsoError::Client(err.msg)),
"EntityDoesNotExistException" => {
return RusotoError::Service(EnableSsoError::EntityDoesNotExist(err.msg))
}
"InsufficientPermissionsException" => {
return RusotoError::Service(EnableSsoError::InsufficientPermissions(err.msg))
}
"ServiceException" => {
return RusotoError::Service(EnableSsoError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for EnableSsoError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
EnableSsoError::AuthenticationFailed(ref cause) => write!(f, "{}", cause),
EnableSsoError::Client(ref cause) => write!(f, "{}", cause),
EnableSsoError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
EnableSsoError::InsufficientPermissions(ref cause) => write!(f, "{}", cause),
EnableSsoError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for EnableSsoError {}
#[derive(Debug, PartialEq)]
pub enum GetDirectoryLimitsError {
Client(String),
EntityDoesNotExist(String),
Service(String),
}
impl GetDirectoryLimitsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDirectoryLimitsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(GetDirectoryLimitsError::Client(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(GetDirectoryLimitsError::EntityDoesNotExist(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(GetDirectoryLimitsError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDirectoryLimitsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDirectoryLimitsError::Client(ref cause) => write!(f, "{}", cause),
GetDirectoryLimitsError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
GetDirectoryLimitsError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDirectoryLimitsError {}
#[derive(Debug, PartialEq)]
pub enum GetSnapshotLimitsError {
Client(String),
EntityDoesNotExist(String),
Service(String),
}
impl GetSnapshotLimitsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetSnapshotLimitsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(GetSnapshotLimitsError::Client(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(GetSnapshotLimitsError::EntityDoesNotExist(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(GetSnapshotLimitsError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetSnapshotLimitsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetSnapshotLimitsError::Client(ref cause) => write!(f, "{}", cause),
GetSnapshotLimitsError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
GetSnapshotLimitsError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetSnapshotLimitsError {}
#[derive(Debug, PartialEq)]
pub enum ListCertificatesError {
Client(String),
DirectoryDoesNotExist(String),
InvalidNextToken(String),
InvalidParameter(String),
Service(String),
UnsupportedOperation(String),
}
impl ListCertificatesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListCertificatesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(ListCertificatesError::Client(err.msg))
}
"DirectoryDoesNotExistException" => {
return RusotoError::Service(ListCertificatesError::DirectoryDoesNotExist(
err.msg,
))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListCertificatesError::InvalidNextToken(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListCertificatesError::InvalidParameter(err.msg))
}
"ServiceException" => {
return RusotoError::Service(ListCertificatesError::Service(err.msg))
}
"UnsupportedOperationException" => {
return RusotoError::Service(ListCertificatesError::UnsupportedOperation(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListCertificatesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListCertificatesError::Client(ref cause) => write!(f, "{}", cause),
ListCertificatesError::DirectoryDoesNotExist(ref cause) => write!(f, "{}", cause),
ListCertificatesError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListCertificatesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListCertificatesError::Service(ref cause) => write!(f, "{}", cause),
ListCertificatesError::UnsupportedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListCertificatesError {}
#[derive(Debug, PartialEq)]
pub enum ListIpRoutesError {
Client(String),
EntityDoesNotExist(String),
InvalidNextToken(String),
InvalidParameter(String),
Service(String),
}
impl ListIpRoutesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListIpRoutesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(ListIpRoutesError::Client(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(ListIpRoutesError::EntityDoesNotExist(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListIpRoutesError::InvalidNextToken(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListIpRoutesError::InvalidParameter(err.msg))
}
"ServiceException" => {
return RusotoError::Service(ListIpRoutesError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListIpRoutesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListIpRoutesError::Client(ref cause) => write!(f, "{}", cause),
ListIpRoutesError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
ListIpRoutesError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListIpRoutesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListIpRoutesError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListIpRoutesError {}
#[derive(Debug, PartialEq)]
pub enum ListLogSubscriptionsError {
Client(String),
EntityDoesNotExist(String),
InvalidNextToken(String),
Service(String),
}
impl ListLogSubscriptionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListLogSubscriptionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(ListLogSubscriptionsError::Client(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(ListLogSubscriptionsError::EntityDoesNotExist(
err.msg,
))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListLogSubscriptionsError::InvalidNextToken(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(ListLogSubscriptionsError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListLogSubscriptionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListLogSubscriptionsError::Client(ref cause) => write!(f, "{}", cause),
ListLogSubscriptionsError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
ListLogSubscriptionsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListLogSubscriptionsError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListLogSubscriptionsError {}
#[derive(Debug, PartialEq)]
pub enum ListSchemaExtensionsError {
Client(String),
EntityDoesNotExist(String),
InvalidNextToken(String),
Service(String),
}
impl ListSchemaExtensionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListSchemaExtensionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(ListSchemaExtensionsError::Client(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(ListSchemaExtensionsError::EntityDoesNotExist(
err.msg,
))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListSchemaExtensionsError::InvalidNextToken(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(ListSchemaExtensionsError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListSchemaExtensionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListSchemaExtensionsError::Client(ref cause) => write!(f, "{}", cause),
ListSchemaExtensionsError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
ListSchemaExtensionsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListSchemaExtensionsError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListSchemaExtensionsError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
Client(String),
EntityDoesNotExist(String),
InvalidNextToken(String),
InvalidParameter(String),
Service(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(ListTagsForResourceError::Client(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(ListTagsForResourceError::EntityDoesNotExist(
err.msg,
))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidNextToken(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidParameter(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(ListTagsForResourceError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsForResourceError::Client(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum RegisterCertificateError {
CertificateAlreadyExists(String),
CertificateLimitExceeded(String),
Client(String),
DirectoryDoesNotExist(String),
DirectoryUnavailable(String),
InvalidCertificate(String),
InvalidParameter(String),
Service(String),
UnsupportedOperation(String),
}
impl RegisterCertificateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RegisterCertificateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CertificateAlreadyExistsException" => {
return RusotoError::Service(
RegisterCertificateError::CertificateAlreadyExists(err.msg),
)
}
"CertificateLimitExceededException" => {
return RusotoError::Service(
RegisterCertificateError::CertificateLimitExceeded(err.msg),
)
}
"ClientException" => {
return RusotoError::Service(RegisterCertificateError::Client(err.msg))
}
"DirectoryDoesNotExistException" => {
return RusotoError::Service(RegisterCertificateError::DirectoryDoesNotExist(
err.msg,
))
}
"DirectoryUnavailableException" => {
return RusotoError::Service(RegisterCertificateError::DirectoryUnavailable(
err.msg,
))
}
"InvalidCertificateException" => {
return RusotoError::Service(RegisterCertificateError::InvalidCertificate(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(RegisterCertificateError::InvalidParameter(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(RegisterCertificateError::Service(err.msg))
}
"UnsupportedOperationException" => {
return RusotoError::Service(RegisterCertificateError::UnsupportedOperation(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RegisterCertificateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RegisterCertificateError::CertificateAlreadyExists(ref cause) => write!(f, "{}", cause),
RegisterCertificateError::CertificateLimitExceeded(ref cause) => write!(f, "{}", cause),
RegisterCertificateError::Client(ref cause) => write!(f, "{}", cause),
RegisterCertificateError::DirectoryDoesNotExist(ref cause) => write!(f, "{}", cause),
RegisterCertificateError::DirectoryUnavailable(ref cause) => write!(f, "{}", cause),
RegisterCertificateError::InvalidCertificate(ref cause) => write!(f, "{}", cause),
RegisterCertificateError::InvalidParameter(ref cause) => write!(f, "{}", cause),
RegisterCertificateError::Service(ref cause) => write!(f, "{}", cause),
RegisterCertificateError::UnsupportedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RegisterCertificateError {}
#[derive(Debug, PartialEq)]
pub enum RegisterEventTopicError {
Client(String),
EntityDoesNotExist(String),
InvalidParameter(String),
Service(String),
}
impl RegisterEventTopicError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RegisterEventTopicError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(RegisterEventTopicError::Client(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(RegisterEventTopicError::EntityDoesNotExist(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(RegisterEventTopicError::InvalidParameter(err.msg))
}
"ServiceException" => {
return RusotoError::Service(RegisterEventTopicError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RegisterEventTopicError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RegisterEventTopicError::Client(ref cause) => write!(f, "{}", cause),
RegisterEventTopicError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
RegisterEventTopicError::InvalidParameter(ref cause) => write!(f, "{}", cause),
RegisterEventTopicError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RegisterEventTopicError {}
#[derive(Debug, PartialEq)]
pub enum RejectSharedDirectoryError {
Client(String),
DirectoryAlreadyShared(String),
EntityDoesNotExist(String),
InvalidParameter(String),
Service(String),
}
impl RejectSharedDirectoryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RejectSharedDirectoryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(RejectSharedDirectoryError::Client(err.msg))
}
"DirectoryAlreadySharedException" => {
return RusotoError::Service(
RejectSharedDirectoryError::DirectoryAlreadyShared(err.msg),
)
}
"EntityDoesNotExistException" => {
return RusotoError::Service(RejectSharedDirectoryError::EntityDoesNotExist(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(RejectSharedDirectoryError::InvalidParameter(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(RejectSharedDirectoryError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RejectSharedDirectoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RejectSharedDirectoryError::Client(ref cause) => write!(f, "{}", cause),
RejectSharedDirectoryError::DirectoryAlreadyShared(ref cause) => write!(f, "{}", cause),
RejectSharedDirectoryError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
RejectSharedDirectoryError::InvalidParameter(ref cause) => write!(f, "{}", cause),
RejectSharedDirectoryError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RejectSharedDirectoryError {}
#[derive(Debug, PartialEq)]
pub enum RemoveIpRoutesError {
Client(String),
DirectoryUnavailable(String),
EntityDoesNotExist(String),
InvalidParameter(String),
Service(String),
}
impl RemoveIpRoutesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RemoveIpRoutesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(RemoveIpRoutesError::Client(err.msg))
}
"DirectoryUnavailableException" => {
return RusotoError::Service(RemoveIpRoutesError::DirectoryUnavailable(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(RemoveIpRoutesError::EntityDoesNotExist(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(RemoveIpRoutesError::InvalidParameter(err.msg))
}
"ServiceException" => {
return RusotoError::Service(RemoveIpRoutesError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RemoveIpRoutesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RemoveIpRoutesError::Client(ref cause) => write!(f, "{}", cause),
RemoveIpRoutesError::DirectoryUnavailable(ref cause) => write!(f, "{}", cause),
RemoveIpRoutesError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
RemoveIpRoutesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
RemoveIpRoutesError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RemoveIpRoutesError {}
#[derive(Debug, PartialEq)]
pub enum RemoveTagsFromResourceError {
Client(String),
EntityDoesNotExist(String),
InvalidParameter(String),
Service(String),
}
impl RemoveTagsFromResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RemoveTagsFromResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(RemoveTagsFromResourceError::Client(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(RemoveTagsFromResourceError::EntityDoesNotExist(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(RemoveTagsFromResourceError::InvalidParameter(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(RemoveTagsFromResourceError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RemoveTagsFromResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RemoveTagsFromResourceError::Client(ref cause) => write!(f, "{}", cause),
RemoveTagsFromResourceError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
RemoveTagsFromResourceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
RemoveTagsFromResourceError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RemoveTagsFromResourceError {}
#[derive(Debug, PartialEq)]
pub enum ResetUserPasswordError {
Client(String),
DirectoryUnavailable(String),
EntityDoesNotExist(String),
InvalidPassword(String),
Service(String),
UnsupportedOperation(String),
UserDoesNotExist(String),
}
impl ResetUserPasswordError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ResetUserPasswordError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(ResetUserPasswordError::Client(err.msg))
}
"DirectoryUnavailableException" => {
return RusotoError::Service(ResetUserPasswordError::DirectoryUnavailable(
err.msg,
))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(ResetUserPasswordError::EntityDoesNotExist(
err.msg,
))
}
"InvalidPasswordException" => {
return RusotoError::Service(ResetUserPasswordError::InvalidPassword(err.msg))
}
"ServiceException" => {
return RusotoError::Service(ResetUserPasswordError::Service(err.msg))
}
"UnsupportedOperationException" => {
return RusotoError::Service(ResetUserPasswordError::UnsupportedOperation(
err.msg,
))
}
"UserDoesNotExistException" => {
return RusotoError::Service(ResetUserPasswordError::UserDoesNotExist(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ResetUserPasswordError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ResetUserPasswordError::Client(ref cause) => write!(f, "{}", cause),
ResetUserPasswordError::DirectoryUnavailable(ref cause) => write!(f, "{}", cause),
ResetUserPasswordError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
ResetUserPasswordError::InvalidPassword(ref cause) => write!(f, "{}", cause),
ResetUserPasswordError::Service(ref cause) => write!(f, "{}", cause),
ResetUserPasswordError::UnsupportedOperation(ref cause) => write!(f, "{}", cause),
ResetUserPasswordError::UserDoesNotExist(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ResetUserPasswordError {}
#[derive(Debug, PartialEq)]
pub enum RestoreFromSnapshotError {
Client(String),
EntityDoesNotExist(String),
InvalidParameter(String),
Service(String),
}
impl RestoreFromSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RestoreFromSnapshotError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(RestoreFromSnapshotError::Client(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(RestoreFromSnapshotError::EntityDoesNotExist(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(RestoreFromSnapshotError::InvalidParameter(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(RestoreFromSnapshotError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RestoreFromSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RestoreFromSnapshotError::Client(ref cause) => write!(f, "{}", cause),
RestoreFromSnapshotError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
RestoreFromSnapshotError::InvalidParameter(ref cause) => write!(f, "{}", cause),
RestoreFromSnapshotError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RestoreFromSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum ShareDirectoryError {
AccessDenied(String),
Client(String),
DirectoryAlreadyShared(String),
EntityDoesNotExist(String),
InvalidParameter(String),
InvalidTarget(String),
Organizations(String),
Service(String),
ShareLimitExceeded(String),
UnsupportedOperation(String),
}
impl ShareDirectoryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ShareDirectoryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ShareDirectoryError::AccessDenied(err.msg))
}
"ClientException" => {
return RusotoError::Service(ShareDirectoryError::Client(err.msg))
}
"DirectoryAlreadySharedException" => {
return RusotoError::Service(ShareDirectoryError::DirectoryAlreadyShared(
err.msg,
))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(ShareDirectoryError::EntityDoesNotExist(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ShareDirectoryError::InvalidParameter(err.msg))
}
"InvalidTargetException" => {
return RusotoError::Service(ShareDirectoryError::InvalidTarget(err.msg))
}
"OrganizationsException" => {
return RusotoError::Service(ShareDirectoryError::Organizations(err.msg))
}
"ServiceException" => {
return RusotoError::Service(ShareDirectoryError::Service(err.msg))
}
"ShareLimitExceededException" => {
return RusotoError::Service(ShareDirectoryError::ShareLimitExceeded(err.msg))
}
"UnsupportedOperationException" => {
return RusotoError::Service(ShareDirectoryError::UnsupportedOperation(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ShareDirectoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ShareDirectoryError::AccessDenied(ref cause) => write!(f, "{}", cause),
ShareDirectoryError::Client(ref cause) => write!(f, "{}", cause),
ShareDirectoryError::DirectoryAlreadyShared(ref cause) => write!(f, "{}", cause),
ShareDirectoryError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
ShareDirectoryError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ShareDirectoryError::InvalidTarget(ref cause) => write!(f, "{}", cause),
ShareDirectoryError::Organizations(ref cause) => write!(f, "{}", cause),
ShareDirectoryError::Service(ref cause) => write!(f, "{}", cause),
ShareDirectoryError::ShareLimitExceeded(ref cause) => write!(f, "{}", cause),
ShareDirectoryError::UnsupportedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ShareDirectoryError {}
#[derive(Debug, PartialEq)]
pub enum StartSchemaExtensionError {
Client(String),
DirectoryUnavailable(String),
EntityDoesNotExist(String),
InvalidParameter(String),
Service(String),
SnapshotLimitExceeded(String),
}
impl StartSchemaExtensionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartSchemaExtensionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(StartSchemaExtensionError::Client(err.msg))
}
"DirectoryUnavailableException" => {
return RusotoError::Service(StartSchemaExtensionError::DirectoryUnavailable(
err.msg,
))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(StartSchemaExtensionError::EntityDoesNotExist(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(StartSchemaExtensionError::InvalidParameter(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(StartSchemaExtensionError::Service(err.msg))
}
"SnapshotLimitExceededException" => {
return RusotoError::Service(StartSchemaExtensionError::SnapshotLimitExceeded(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartSchemaExtensionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartSchemaExtensionError::Client(ref cause) => write!(f, "{}", cause),
StartSchemaExtensionError::DirectoryUnavailable(ref cause) => write!(f, "{}", cause),
StartSchemaExtensionError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
StartSchemaExtensionError::InvalidParameter(ref cause) => write!(f, "{}", cause),
StartSchemaExtensionError::Service(ref cause) => write!(f, "{}", cause),
StartSchemaExtensionError::SnapshotLimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartSchemaExtensionError {}
#[derive(Debug, PartialEq)]
pub enum UnshareDirectoryError {
Client(String),
DirectoryNotShared(String),
EntityDoesNotExist(String),
InvalidTarget(String),
Service(String),
}
impl UnshareDirectoryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UnshareDirectoryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(UnshareDirectoryError::Client(err.msg))
}
"DirectoryNotSharedException" => {
return RusotoError::Service(UnshareDirectoryError::DirectoryNotShared(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(UnshareDirectoryError::EntityDoesNotExist(err.msg))
}
"InvalidTargetException" => {
return RusotoError::Service(UnshareDirectoryError::InvalidTarget(err.msg))
}
"ServiceException" => {
return RusotoError::Service(UnshareDirectoryError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UnshareDirectoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UnshareDirectoryError::Client(ref cause) => write!(f, "{}", cause),
UnshareDirectoryError::DirectoryNotShared(ref cause) => write!(f, "{}", cause),
UnshareDirectoryError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
UnshareDirectoryError::InvalidTarget(ref cause) => write!(f, "{}", cause),
UnshareDirectoryError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UnshareDirectoryError {}
#[derive(Debug, PartialEq)]
pub enum UpdateConditionalForwarderError {
Client(String),
DirectoryUnavailable(String),
EntityDoesNotExist(String),
InvalidParameter(String),
Service(String),
UnsupportedOperation(String),
}
impl UpdateConditionalForwarderError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateConditionalForwarderError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(UpdateConditionalForwarderError::Client(err.msg))
}
"DirectoryUnavailableException" => {
return RusotoError::Service(
UpdateConditionalForwarderError::DirectoryUnavailable(err.msg),
)
}
"EntityDoesNotExistException" => {
return RusotoError::Service(
UpdateConditionalForwarderError::EntityDoesNotExist(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateConditionalForwarderError::InvalidParameter(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(UpdateConditionalForwarderError::Service(err.msg))
}
"UnsupportedOperationException" => {
return RusotoError::Service(
UpdateConditionalForwarderError::UnsupportedOperation(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateConditionalForwarderError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateConditionalForwarderError::Client(ref cause) => write!(f, "{}", cause),
UpdateConditionalForwarderError::DirectoryUnavailable(ref cause) => {
write!(f, "{}", cause)
}
UpdateConditionalForwarderError::EntityDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
UpdateConditionalForwarderError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateConditionalForwarderError::Service(ref cause) => write!(f, "{}", cause),
UpdateConditionalForwarderError::UnsupportedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateConditionalForwarderError {}
#[derive(Debug, PartialEq)]
pub enum UpdateNumberOfDomainControllersError {
Client(String),
DirectoryUnavailable(String),
DomainControllerLimitExceeded(String),
EntityDoesNotExist(String),
InvalidParameter(String),
Service(String),
UnsupportedOperation(String),
}
impl UpdateNumberOfDomainControllersError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateNumberOfDomainControllersError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(UpdateNumberOfDomainControllersError::Client(
err.msg,
))
}
"DirectoryUnavailableException" => {
return RusotoError::Service(
UpdateNumberOfDomainControllersError::DirectoryUnavailable(err.msg),
)
}
"DomainControllerLimitExceededException" => {
return RusotoError::Service(
UpdateNumberOfDomainControllersError::DomainControllerLimitExceeded(
err.msg,
),
)
}
"EntityDoesNotExistException" => {
return RusotoError::Service(
UpdateNumberOfDomainControllersError::EntityDoesNotExist(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(
UpdateNumberOfDomainControllersError::InvalidParameter(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(UpdateNumberOfDomainControllersError::Service(
err.msg,
))
}
"UnsupportedOperationException" => {
return RusotoError::Service(
UpdateNumberOfDomainControllersError::UnsupportedOperation(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateNumberOfDomainControllersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateNumberOfDomainControllersError::Client(ref cause) => write!(f, "{}", cause),
UpdateNumberOfDomainControllersError::DirectoryUnavailable(ref cause) => {
write!(f, "{}", cause)
}
UpdateNumberOfDomainControllersError::DomainControllerLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
UpdateNumberOfDomainControllersError::EntityDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
UpdateNumberOfDomainControllersError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
UpdateNumberOfDomainControllersError::Service(ref cause) => write!(f, "{}", cause),
UpdateNumberOfDomainControllersError::UnsupportedOperation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateNumberOfDomainControllersError {}
#[derive(Debug, PartialEq)]
pub enum UpdateRadiusError {
Client(String),
EntityDoesNotExist(String),
InvalidParameter(String),
Service(String),
}
impl UpdateRadiusError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateRadiusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(UpdateRadiusError::Client(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(UpdateRadiusError::EntityDoesNotExist(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateRadiusError::InvalidParameter(err.msg))
}
"ServiceException" => {
return RusotoError::Service(UpdateRadiusError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateRadiusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateRadiusError::Client(ref cause) => write!(f, "{}", cause),
UpdateRadiusError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
UpdateRadiusError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateRadiusError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateRadiusError {}
#[derive(Debug, PartialEq)]
pub enum UpdateTrustError {
Client(String),
EntityDoesNotExist(String),
InvalidParameter(String),
Service(String),
}
impl UpdateTrustError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateTrustError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(UpdateTrustError::Client(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(UpdateTrustError::EntityDoesNotExist(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateTrustError::InvalidParameter(err.msg))
}
"ServiceException" => {
return RusotoError::Service(UpdateTrustError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateTrustError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateTrustError::Client(ref cause) => write!(f, "{}", cause),
UpdateTrustError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
UpdateTrustError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateTrustError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateTrustError {}
#[derive(Debug, PartialEq)]
pub enum VerifyTrustError {
Client(String),
EntityDoesNotExist(String),
InvalidParameter(String),
Service(String),
UnsupportedOperation(String),
}
impl VerifyTrustError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<VerifyTrustError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientException" => {
return RusotoError::Service(VerifyTrustError::Client(err.msg))
}
"EntityDoesNotExistException" => {
return RusotoError::Service(VerifyTrustError::EntityDoesNotExist(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(VerifyTrustError::InvalidParameter(err.msg))
}
"ServiceException" => {
return RusotoError::Service(VerifyTrustError::Service(err.msg))
}
"UnsupportedOperationException" => {
return RusotoError::Service(VerifyTrustError::UnsupportedOperation(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for VerifyTrustError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
VerifyTrustError::Client(ref cause) => write!(f, "{}", cause),
VerifyTrustError::EntityDoesNotExist(ref cause) => write!(f, "{}", cause),
VerifyTrustError::InvalidParameter(ref cause) => write!(f, "{}", cause),
VerifyTrustError::Service(ref cause) => write!(f, "{}", cause),
VerifyTrustError::UnsupportedOperation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for VerifyTrustError {}
#[async_trait]
pub trait DirectoryService {
async fn accept_shared_directory(
&self,
input: AcceptSharedDirectoryRequest,
) -> Result<AcceptSharedDirectoryResult, RusotoError<AcceptSharedDirectoryError>>;
async fn add_ip_routes(
&self,
input: AddIpRoutesRequest,
) -> Result<AddIpRoutesResult, RusotoError<AddIpRoutesError>>;
async fn add_tags_to_resource(
&self,
input: AddTagsToResourceRequest,
) -> Result<AddTagsToResourceResult, RusotoError<AddTagsToResourceError>>;
async fn cancel_schema_extension(
&self,
input: CancelSchemaExtensionRequest,
) -> Result<CancelSchemaExtensionResult, RusotoError<CancelSchemaExtensionError>>;
async fn connect_directory(
&self,
input: ConnectDirectoryRequest,
) -> Result<ConnectDirectoryResult, RusotoError<ConnectDirectoryError>>;
async fn create_alias(
&self,
input: CreateAliasRequest,
) -> Result<CreateAliasResult, RusotoError<CreateAliasError>>;
async fn create_computer(
&self,
input: CreateComputerRequest,
) -> Result<CreateComputerResult, RusotoError<CreateComputerError>>;
async fn create_conditional_forwarder(
&self,
input: CreateConditionalForwarderRequest,
) -> Result<CreateConditionalForwarderResult, RusotoError<CreateConditionalForwarderError>>;
async fn create_directory(
&self,
input: CreateDirectoryRequest,
) -> Result<CreateDirectoryResult, RusotoError<CreateDirectoryError>>;
async fn create_log_subscription(
&self,
input: CreateLogSubscriptionRequest,
) -> Result<CreateLogSubscriptionResult, RusotoError<CreateLogSubscriptionError>>;
async fn create_microsoft_ad(
&self,
input: CreateMicrosoftADRequest,
) -> Result<CreateMicrosoftADResult, RusotoError<CreateMicrosoftADError>>;
async fn create_snapshot(
&self,
input: CreateSnapshotRequest,
) -> Result<CreateSnapshotResult, RusotoError<CreateSnapshotError>>;
async fn create_trust(
&self,
input: CreateTrustRequest,
) -> Result<CreateTrustResult, RusotoError<CreateTrustError>>;
async fn delete_conditional_forwarder(
&self,
input: DeleteConditionalForwarderRequest,
) -> Result<DeleteConditionalForwarderResult, RusotoError<DeleteConditionalForwarderError>>;
async fn delete_directory(
&self,
input: DeleteDirectoryRequest,
) -> Result<DeleteDirectoryResult, RusotoError<DeleteDirectoryError>>;
async fn delete_log_subscription(
&self,
input: DeleteLogSubscriptionRequest,
) -> Result<DeleteLogSubscriptionResult, RusotoError<DeleteLogSubscriptionError>>;
async fn delete_snapshot(
&self,
input: DeleteSnapshotRequest,
) -> Result<DeleteSnapshotResult, RusotoError<DeleteSnapshotError>>;
async fn delete_trust(
&self,
input: DeleteTrustRequest,
) -> Result<DeleteTrustResult, RusotoError<DeleteTrustError>>;
async fn deregister_certificate(
&self,
input: DeregisterCertificateRequest,
) -> Result<DeregisterCertificateResult, RusotoError<DeregisterCertificateError>>;
async fn deregister_event_topic(
&self,
input: DeregisterEventTopicRequest,
) -> Result<DeregisterEventTopicResult, RusotoError<DeregisterEventTopicError>>;
async fn describe_certificate(
&self,
input: DescribeCertificateRequest,
) -> Result<DescribeCertificateResult, RusotoError<DescribeCertificateError>>;
async fn describe_conditional_forwarders(
&self,
input: DescribeConditionalForwardersRequest,
) -> Result<DescribeConditionalForwardersResult, RusotoError<DescribeConditionalForwardersError>>;
async fn describe_directories(
&self,
input: DescribeDirectoriesRequest,
) -> Result<DescribeDirectoriesResult, RusotoError<DescribeDirectoriesError>>;
async fn describe_domain_controllers(
&self,
input: DescribeDomainControllersRequest,
) -> Result<DescribeDomainControllersResult, RusotoError<DescribeDomainControllersError>>;
async fn describe_event_topics(
&self,
input: DescribeEventTopicsRequest,
) -> Result<DescribeEventTopicsResult, RusotoError<DescribeEventTopicsError>>;
async fn describe_ldaps_settings(
&self,
input: DescribeLDAPSSettingsRequest,
) -> Result<DescribeLDAPSSettingsResult, RusotoError<DescribeLDAPSSettingsError>>;
async fn describe_shared_directories(
&self,
input: DescribeSharedDirectoriesRequest,
) -> Result<DescribeSharedDirectoriesResult, RusotoError<DescribeSharedDirectoriesError>>;
async fn describe_snapshots(
&self,
input: DescribeSnapshotsRequest,
) -> Result<DescribeSnapshotsResult, RusotoError<DescribeSnapshotsError>>;
async fn describe_trusts(
&self,
input: DescribeTrustsRequest,
) -> Result<DescribeTrustsResult, RusotoError<DescribeTrustsError>>;
async fn disable_ldaps(
&self,
input: DisableLDAPSRequest,
) -> Result<DisableLDAPSResult, RusotoError<DisableLDAPSError>>;
async fn disable_radius(
&self,
input: DisableRadiusRequest,
) -> Result<DisableRadiusResult, RusotoError<DisableRadiusError>>;
async fn disable_sso(
&self,
input: DisableSsoRequest,
) -> Result<DisableSsoResult, RusotoError<DisableSsoError>>;
async fn enable_ldaps(
&self,
input: EnableLDAPSRequest,
) -> Result<EnableLDAPSResult, RusotoError<EnableLDAPSError>>;
async fn enable_radius(
&self,
input: EnableRadiusRequest,
) -> Result<EnableRadiusResult, RusotoError<EnableRadiusError>>;
async fn enable_sso(
&self,
input: EnableSsoRequest,
) -> Result<EnableSsoResult, RusotoError<EnableSsoError>>;
async fn get_directory_limits(
&self,
) -> Result<GetDirectoryLimitsResult, RusotoError<GetDirectoryLimitsError>>;
async fn get_snapshot_limits(
&self,
input: GetSnapshotLimitsRequest,
) -> Result<GetSnapshotLimitsResult, RusotoError<GetSnapshotLimitsError>>;
async fn list_certificates(
&self,
input: ListCertificatesRequest,
) -> Result<ListCertificatesResult, RusotoError<ListCertificatesError>>;
async fn list_ip_routes(
&self,
input: ListIpRoutesRequest,
) -> Result<ListIpRoutesResult, RusotoError<ListIpRoutesError>>;
async fn list_log_subscriptions(
&self,
input: ListLogSubscriptionsRequest,
) -> Result<ListLogSubscriptionsResult, RusotoError<ListLogSubscriptionsError>>;
async fn list_schema_extensions(
&self,
input: ListSchemaExtensionsRequest,
) -> Result<ListSchemaExtensionsResult, RusotoError<ListSchemaExtensionsError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResult, RusotoError<ListTagsForResourceError>>;
async fn register_certificate(
&self,
input: RegisterCertificateRequest,
) -> Result<RegisterCertificateResult, RusotoError<RegisterCertificateError>>;
async fn register_event_topic(
&self,
input: RegisterEventTopicRequest,
) -> Result<RegisterEventTopicResult, RusotoError<RegisterEventTopicError>>;
async fn reject_shared_directory(
&self,
input: RejectSharedDirectoryRequest,
) -> Result<RejectSharedDirectoryResult, RusotoError<RejectSharedDirectoryError>>;
async fn remove_ip_routes(
&self,
input: RemoveIpRoutesRequest,
) -> Result<RemoveIpRoutesResult, RusotoError<RemoveIpRoutesError>>;
async fn remove_tags_from_resource(
&self,
input: RemoveTagsFromResourceRequest,
) -> Result<RemoveTagsFromResourceResult, RusotoError<RemoveTagsFromResourceError>>;
async fn reset_user_password(
&self,
input: ResetUserPasswordRequest,
) -> Result<ResetUserPasswordResult, RusotoError<ResetUserPasswordError>>;
async fn restore_from_snapshot(
&self,
input: RestoreFromSnapshotRequest,
) -> Result<RestoreFromSnapshotResult, RusotoError<RestoreFromSnapshotError>>;
async fn share_directory(
&self,
input: ShareDirectoryRequest,
) -> Result<ShareDirectoryResult, RusotoError<ShareDirectoryError>>;
async fn start_schema_extension(
&self,
input: StartSchemaExtensionRequest,
) -> Result<StartSchemaExtensionResult, RusotoError<StartSchemaExtensionError>>;
async fn unshare_directory(
&self,
input: UnshareDirectoryRequest,
) -> Result<UnshareDirectoryResult, RusotoError<UnshareDirectoryError>>;
async fn update_conditional_forwarder(
&self,
input: UpdateConditionalForwarderRequest,
) -> Result<UpdateConditionalForwarderResult, RusotoError<UpdateConditionalForwarderError>>;
async fn update_number_of_domain_controllers(
&self,
input: UpdateNumberOfDomainControllersRequest,
) -> Result<
UpdateNumberOfDomainControllersResult,
RusotoError<UpdateNumberOfDomainControllersError>,
>;
async fn update_radius(
&self,
input: UpdateRadiusRequest,
) -> Result<UpdateRadiusResult, RusotoError<UpdateRadiusError>>;
async fn update_trust(
&self,
input: UpdateTrustRequest,
) -> Result<UpdateTrustResult, RusotoError<UpdateTrustError>>;
async fn verify_trust(
&self,
input: VerifyTrustRequest,
) -> Result<VerifyTrustResult, RusotoError<VerifyTrustError>>;
}
#[derive(Clone)]
pub struct DirectoryServiceClient {
client: Client,
region: region::Region,
}
impl DirectoryServiceClient {
pub fn new(region: region::Region) -> DirectoryServiceClient {
DirectoryServiceClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> DirectoryServiceClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
DirectoryServiceClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> DirectoryServiceClient {
DirectoryServiceClient { client, region }
}
}
#[async_trait]
impl DirectoryService for DirectoryServiceClient {
async fn accept_shared_directory(
&self,
input: AcceptSharedDirectoryRequest,
) -> Result<AcceptSharedDirectoryResult, RusotoError<AcceptSharedDirectoryError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.AcceptSharedDirectory",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AcceptSharedDirectoryError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<AcceptSharedDirectoryResult, _>()
}
async fn add_ip_routes(
&self,
input: AddIpRoutesRequest,
) -> Result<AddIpRoutesResult, RusotoError<AddIpRoutesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DirectoryService_20150416.AddIpRoutes");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AddIpRoutesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<AddIpRoutesResult, _>()
}
async fn add_tags_to_resource(
&self,
input: AddTagsToResourceRequest,
) -> Result<AddTagsToResourceResult, RusotoError<AddTagsToResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.AddTagsToResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AddTagsToResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<AddTagsToResourceResult, _>()
}
async fn cancel_schema_extension(
&self,
input: CancelSchemaExtensionRequest,
) -> Result<CancelSchemaExtensionResult, RusotoError<CancelSchemaExtensionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.CancelSchemaExtension",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CancelSchemaExtensionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CancelSchemaExtensionResult, _>()
}
async fn connect_directory(
&self,
input: ConnectDirectoryRequest,
) -> Result<ConnectDirectoryResult, RusotoError<ConnectDirectoryError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DirectoryService_20150416.ConnectDirectory");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ConnectDirectoryError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ConnectDirectoryResult, _>()
}
async fn create_alias(
&self,
input: CreateAliasRequest,
) -> Result<CreateAliasResult, RusotoError<CreateAliasError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DirectoryService_20150416.CreateAlias");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateAliasError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateAliasResult, _>()
}
async fn create_computer(
&self,
input: CreateComputerRequest,
) -> Result<CreateComputerResult, RusotoError<CreateComputerError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DirectoryService_20150416.CreateComputer");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateComputerError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateComputerResult, _>()
}
async fn create_conditional_forwarder(
&self,
input: CreateConditionalForwarderRequest,
) -> Result<CreateConditionalForwarderResult, RusotoError<CreateConditionalForwarderError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.CreateConditionalForwarder",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateConditionalForwarderError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateConditionalForwarderResult, _>()
}
async fn create_directory(
&self,
input: CreateDirectoryRequest,
) -> Result<CreateDirectoryResult, RusotoError<CreateDirectoryError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DirectoryService_20150416.CreateDirectory");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateDirectoryError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateDirectoryResult, _>()
}
async fn create_log_subscription(
&self,
input: CreateLogSubscriptionRequest,
) -> Result<CreateLogSubscriptionResult, RusotoError<CreateLogSubscriptionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.CreateLogSubscription",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateLogSubscriptionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateLogSubscriptionResult, _>()
}
async fn create_microsoft_ad(
&self,
input: CreateMicrosoftADRequest,
) -> Result<CreateMicrosoftADResult, RusotoError<CreateMicrosoftADError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.CreateMicrosoftAD",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateMicrosoftADError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateMicrosoftADResult, _>()
}
async fn create_snapshot(
&self,
input: CreateSnapshotRequest,
) -> Result<CreateSnapshotResult, RusotoError<CreateSnapshotError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DirectoryService_20150416.CreateSnapshot");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateSnapshotError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateSnapshotResult, _>()
}
async fn create_trust(
&self,
input: CreateTrustRequest,
) -> Result<CreateTrustResult, RusotoError<CreateTrustError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DirectoryService_20150416.CreateTrust");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateTrustError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateTrustResult, _>()
}
async fn delete_conditional_forwarder(
&self,
input: DeleteConditionalForwarderRequest,
) -> Result<DeleteConditionalForwarderResult, RusotoError<DeleteConditionalForwarderError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.DeleteConditionalForwarder",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteConditionalForwarderError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteConditionalForwarderResult, _>()
}
async fn delete_directory(
&self,
input: DeleteDirectoryRequest,
) -> Result<DeleteDirectoryResult, RusotoError<DeleteDirectoryError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DirectoryService_20150416.DeleteDirectory");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteDirectoryError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteDirectoryResult, _>()
}
async fn delete_log_subscription(
&self,
input: DeleteLogSubscriptionRequest,
) -> Result<DeleteLogSubscriptionResult, RusotoError<DeleteLogSubscriptionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.DeleteLogSubscription",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteLogSubscriptionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteLogSubscriptionResult, _>()
}
async fn delete_snapshot(
&self,
input: DeleteSnapshotRequest,
) -> Result<DeleteSnapshotResult, RusotoError<DeleteSnapshotError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DirectoryService_20150416.DeleteSnapshot");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteSnapshotError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteSnapshotResult, _>()
}
async fn delete_trust(
&self,
input: DeleteTrustRequest,
) -> Result<DeleteTrustResult, RusotoError<DeleteTrustError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DirectoryService_20150416.DeleteTrust");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteTrustError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteTrustResult, _>()
}
async fn deregister_certificate(
&self,
input: DeregisterCertificateRequest,
) -> Result<DeregisterCertificateResult, RusotoError<DeregisterCertificateError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.DeregisterCertificate",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeregisterCertificateError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeregisterCertificateResult, _>()
}
async fn deregister_event_topic(
&self,
input: DeregisterEventTopicRequest,
) -> Result<DeregisterEventTopicResult, RusotoError<DeregisterEventTopicError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.DeregisterEventTopic",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeregisterEventTopicError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeregisterEventTopicResult, _>()
}
async fn describe_certificate(
&self,
input: DescribeCertificateRequest,
) -> Result<DescribeCertificateResult, RusotoError<DescribeCertificateError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.DescribeCertificate",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeCertificateError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeCertificateResult, _>()
}
async fn describe_conditional_forwarders(
&self,
input: DescribeConditionalForwardersRequest,
) -> Result<DescribeConditionalForwardersResult, RusotoError<DescribeConditionalForwardersError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.DescribeConditionalForwarders",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeConditionalForwardersError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeConditionalForwardersResult, _>()
}
async fn describe_directories(
&self,
input: DescribeDirectoriesRequest,
) -> Result<DescribeDirectoriesResult, RusotoError<DescribeDirectoriesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.DescribeDirectories",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeDirectoriesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeDirectoriesResult, _>()
}
async fn describe_domain_controllers(
&self,
input: DescribeDomainControllersRequest,
) -> Result<DescribeDomainControllersResult, RusotoError<DescribeDomainControllersError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.DescribeDomainControllers",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeDomainControllersError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeDomainControllersResult, _>()
}
async fn describe_event_topics(
&self,
input: DescribeEventTopicsRequest,
) -> Result<DescribeEventTopicsResult, RusotoError<DescribeEventTopicsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.DescribeEventTopics",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeEventTopicsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeEventTopicsResult, _>()
}
async fn describe_ldaps_settings(
&self,
input: DescribeLDAPSSettingsRequest,
) -> Result<DescribeLDAPSSettingsResult, RusotoError<DescribeLDAPSSettingsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.DescribeLDAPSSettings",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeLDAPSSettingsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeLDAPSSettingsResult, _>()
}
async fn describe_shared_directories(
&self,
input: DescribeSharedDirectoriesRequest,
) -> Result<DescribeSharedDirectoriesResult, RusotoError<DescribeSharedDirectoriesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.DescribeSharedDirectories",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeSharedDirectoriesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeSharedDirectoriesResult, _>()
}
async fn describe_snapshots(
&self,
input: DescribeSnapshotsRequest,
) -> Result<DescribeSnapshotsResult, RusotoError<DescribeSnapshotsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.DescribeSnapshots",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeSnapshotsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeSnapshotsResult, _>()
}
async fn describe_trusts(
&self,
input: DescribeTrustsRequest,
) -> Result<DescribeTrustsResult, RusotoError<DescribeTrustsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DirectoryService_20150416.DescribeTrusts");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeTrustsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeTrustsResult, _>()
}
async fn disable_ldaps(
&self,
input: DisableLDAPSRequest,
) -> Result<DisableLDAPSResult, RusotoError<DisableLDAPSError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DirectoryService_20150416.DisableLDAPS");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DisableLDAPSError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DisableLDAPSResult, _>()
}
async fn disable_radius(
&self,
input: DisableRadiusRequest,
) -> Result<DisableRadiusResult, RusotoError<DisableRadiusError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DirectoryService_20150416.DisableRadius");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DisableRadiusError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DisableRadiusResult, _>()
}
async fn disable_sso(
&self,
input: DisableSsoRequest,
) -> Result<DisableSsoResult, RusotoError<DisableSsoError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DirectoryService_20150416.DisableSso");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DisableSsoError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DisableSsoResult, _>()
}
async fn enable_ldaps(
&self,
input: EnableLDAPSRequest,
) -> Result<EnableLDAPSResult, RusotoError<EnableLDAPSError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DirectoryService_20150416.EnableLDAPS");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, EnableLDAPSError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<EnableLDAPSResult, _>()
}
async fn enable_radius(
&self,
input: EnableRadiusRequest,
) -> Result<EnableRadiusResult, RusotoError<EnableRadiusError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DirectoryService_20150416.EnableRadius");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, EnableRadiusError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<EnableRadiusResult, _>()
}
async fn enable_sso(
&self,
input: EnableSsoRequest,
) -> Result<EnableSsoResult, RusotoError<EnableSsoError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DirectoryService_20150416.EnableSso");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, EnableSsoError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<EnableSsoResult, _>()
}
async fn get_directory_limits(
&self,
) -> Result<GetDirectoryLimitsResult, RusotoError<GetDirectoryLimitsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.GetDirectoryLimits",
);
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(request, GetDirectoryLimitsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetDirectoryLimitsResult, _>()
}
async fn get_snapshot_limits(
&self,
input: GetSnapshotLimitsRequest,
) -> Result<GetSnapshotLimitsResult, RusotoError<GetSnapshotLimitsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.GetSnapshotLimits",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetSnapshotLimitsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetSnapshotLimitsResult, _>()
}
async fn list_certificates(
&self,
input: ListCertificatesRequest,
) -> Result<ListCertificatesResult, RusotoError<ListCertificatesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DirectoryService_20150416.ListCertificates");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListCertificatesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListCertificatesResult, _>()
}
async fn list_ip_routes(
&self,
input: ListIpRoutesRequest,
) -> Result<ListIpRoutesResult, RusotoError<ListIpRoutesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DirectoryService_20150416.ListIpRoutes");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListIpRoutesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListIpRoutesResult, _>()
}
async fn list_log_subscriptions(
&self,
input: ListLogSubscriptionsRequest,
) -> Result<ListLogSubscriptionsResult, RusotoError<ListLogSubscriptionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.ListLogSubscriptions",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListLogSubscriptionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListLogSubscriptionsResult, _>()
}
async fn list_schema_extensions(
&self,
input: ListSchemaExtensionsRequest,
) -> Result<ListSchemaExtensionsResult, RusotoError<ListSchemaExtensionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.ListSchemaExtensions",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListSchemaExtensionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListSchemaExtensionsResult, _>()
}
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResult, RusotoError<ListTagsForResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.ListTagsForResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListTagsForResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListTagsForResourceResult, _>()
}
async fn register_certificate(
&self,
input: RegisterCertificateRequest,
) -> Result<RegisterCertificateResult, RusotoError<RegisterCertificateError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.RegisterCertificate",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, RegisterCertificateError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<RegisterCertificateResult, _>()
}
async fn register_event_topic(
&self,
input: RegisterEventTopicRequest,
) -> Result<RegisterEventTopicResult, RusotoError<RegisterEventTopicError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.RegisterEventTopic",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, RegisterEventTopicError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<RegisterEventTopicResult, _>()
}
async fn reject_shared_directory(
&self,
input: RejectSharedDirectoryRequest,
) -> Result<RejectSharedDirectoryResult, RusotoError<RejectSharedDirectoryError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.RejectSharedDirectory",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, RejectSharedDirectoryError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<RejectSharedDirectoryResult, _>()
}
async fn remove_ip_routes(
&self,
input: RemoveIpRoutesRequest,
) -> Result<RemoveIpRoutesResult, RusotoError<RemoveIpRoutesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DirectoryService_20150416.RemoveIpRoutes");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, RemoveIpRoutesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<RemoveIpRoutesResult, _>()
}
async fn remove_tags_from_resource(
&self,
input: RemoveTagsFromResourceRequest,
) -> Result<RemoveTagsFromResourceResult, RusotoError<RemoveTagsFromResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.RemoveTagsFromResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, RemoveTagsFromResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<RemoveTagsFromResourceResult, _>()
}
async fn reset_user_password(
&self,
input: ResetUserPasswordRequest,
) -> Result<ResetUserPasswordResult, RusotoError<ResetUserPasswordError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.ResetUserPassword",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ResetUserPasswordError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ResetUserPasswordResult, _>()
}
async fn restore_from_snapshot(
&self,
input: RestoreFromSnapshotRequest,
) -> Result<RestoreFromSnapshotResult, RusotoError<RestoreFromSnapshotError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.RestoreFromSnapshot",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, RestoreFromSnapshotError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<RestoreFromSnapshotResult, _>()
}
async fn share_directory(
&self,
input: ShareDirectoryRequest,
) -> Result<ShareDirectoryResult, RusotoError<ShareDirectoryError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DirectoryService_20150416.ShareDirectory");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ShareDirectoryError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ShareDirectoryResult, _>()
}
async fn start_schema_extension(
&self,
input: StartSchemaExtensionRequest,
) -> Result<StartSchemaExtensionResult, RusotoError<StartSchemaExtensionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.StartSchemaExtension",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StartSchemaExtensionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<StartSchemaExtensionResult, _>()
}
async fn unshare_directory(
&self,
input: UnshareDirectoryRequest,
) -> Result<UnshareDirectoryResult, RusotoError<UnshareDirectoryError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DirectoryService_20150416.UnshareDirectory");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UnshareDirectoryError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UnshareDirectoryResult, _>()
}
async fn update_conditional_forwarder(
&self,
input: UpdateConditionalForwarderRequest,
) -> Result<UpdateConditionalForwarderResult, RusotoError<UpdateConditionalForwarderError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.UpdateConditionalForwarder",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateConditionalForwarderError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateConditionalForwarderResult, _>()
}
async fn update_number_of_domain_controllers(
&self,
input: UpdateNumberOfDomainControllersRequest,
) -> Result<
UpdateNumberOfDomainControllersResult,
RusotoError<UpdateNumberOfDomainControllersError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"DirectoryService_20150416.UpdateNumberOfDomainControllers",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateNumberOfDomainControllersError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateNumberOfDomainControllersResult, _>()
}
async fn update_radius(
&self,
input: UpdateRadiusRequest,
) -> Result<UpdateRadiusResult, RusotoError<UpdateRadiusError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DirectoryService_20150416.UpdateRadius");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateRadiusError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateRadiusResult, _>()
}
async fn update_trust(
&self,
input: UpdateTrustRequest,
) -> Result<UpdateTrustResult, RusotoError<UpdateTrustError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DirectoryService_20150416.UpdateTrust");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateTrustError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateTrustResult, _>()
}
async fn verify_trust(
&self,
input: VerifyTrustRequest,
) -> Result<VerifyTrustResult, RusotoError<VerifyTrustError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "DirectoryService_20150416.VerifyTrust");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, VerifyTrustError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<VerifyTrustResult, _>()
}
}