use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::param::{Params, ServiceParams};
use rusoto_core::proto;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
use serde_json;
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AssociateDomainRequest {
#[serde(rename = "AcmCertificateArn")]
pub acm_certificate_arn: String,
#[serde(rename = "DisplayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(rename = "DomainName")]
pub domain_name: String,
#[serde(rename = "FleetArn")]
pub fleet_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssociateDomainResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AssociateWebsiteAuthorizationProviderRequest {
#[serde(rename = "AuthorizationProviderType")]
pub authorization_provider_type: String,
#[serde(rename = "DomainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name: Option<String>,
#[serde(rename = "FleetArn")]
pub fleet_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssociateWebsiteAuthorizationProviderResponse {
#[serde(rename = "AuthorizationProviderId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorization_provider_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AssociateWebsiteCertificateAuthorityRequest {
#[serde(rename = "Certificate")]
pub certificate: String,
#[serde(rename = "DisplayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(rename = "FleetArn")]
pub fleet_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssociateWebsiteCertificateAuthorityResponse {
#[serde(rename = "WebsiteCaId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub website_ca_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateFleetRequest {
#[serde(rename = "DisplayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(rename = "FleetName")]
pub fleet_name: String,
#[serde(rename = "OptimizeForEndUserLocation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub optimize_for_end_user_location: Option<bool>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateFleetResponse {
#[serde(rename = "FleetArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fleet_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteFleetRequest {
#[serde(rename = "FleetArn")]
pub fleet_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteFleetResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeAuditStreamConfigurationRequest {
#[serde(rename = "FleetArn")]
pub fleet_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeAuditStreamConfigurationResponse {
#[serde(rename = "AuditStreamArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub audit_stream_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeCompanyNetworkConfigurationRequest {
#[serde(rename = "FleetArn")]
pub fleet_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeCompanyNetworkConfigurationResponse {
#[serde(rename = "SecurityGroupIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_group_ids: Option<Vec<String>>,
#[serde(rename = "SubnetIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_ids: Option<Vec<String>>,
#[serde(rename = "VpcId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeDevicePolicyConfigurationRequest {
#[serde(rename = "FleetArn")]
pub fleet_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeDevicePolicyConfigurationResponse {
#[serde(rename = "DeviceCaCertificate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_ca_certificate: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeDeviceRequest {
#[serde(rename = "DeviceId")]
pub device_id: String,
#[serde(rename = "FleetArn")]
pub fleet_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeDeviceResponse {
#[serde(rename = "FirstAccessedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub first_accessed_time: Option<f64>,
#[serde(rename = "LastAccessedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_accessed_time: Option<f64>,
#[serde(rename = "Manufacturer")]
#[serde(skip_serializing_if = "Option::is_none")]
pub manufacturer: Option<String>,
#[serde(rename = "Model")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model: Option<String>,
#[serde(rename = "OperatingSystem")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operating_system: Option<String>,
#[serde(rename = "OperatingSystemVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operating_system_version: Option<String>,
#[serde(rename = "PatchLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub patch_level: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "Username")]
#[serde(skip_serializing_if = "Option::is_none")]
pub username: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeDomainRequest {
#[serde(rename = "DomainName")]
pub domain_name: String,
#[serde(rename = "FleetArn")]
pub fleet_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeDomainResponse {
#[serde(rename = "AcmCertificateArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub acm_certificate_arn: Option<String>,
#[serde(rename = "CreatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_time: Option<f64>,
#[serde(rename = "DisplayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(rename = "DomainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name: Option<String>,
#[serde(rename = "DomainStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_status: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeFleetMetadataRequest {
#[serde(rename = "FleetArn")]
pub fleet_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeFleetMetadataResponse {
#[serde(rename = "CompanyCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub company_code: Option<String>,
#[serde(rename = "CreatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_time: Option<f64>,
#[serde(rename = "DisplayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(rename = "FleetName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fleet_name: Option<String>,
#[serde(rename = "FleetStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fleet_status: Option<String>,
#[serde(rename = "LastUpdatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_time: Option<f64>,
#[serde(rename = "OptimizeForEndUserLocation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub optimize_for_end_user_location: Option<bool>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeIdentityProviderConfigurationRequest {
#[serde(rename = "FleetArn")]
pub fleet_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeIdentityProviderConfigurationResponse {
#[serde(rename = "IdentityProviderSamlMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_provider_saml_metadata: Option<String>,
#[serde(rename = "IdentityProviderType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_provider_type: Option<String>,
#[serde(rename = "ServiceProviderSamlMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_provider_saml_metadata: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeWebsiteCertificateAuthorityRequest {
#[serde(rename = "FleetArn")]
pub fleet_arn: String,
#[serde(rename = "WebsiteCaId")]
pub website_ca_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeWebsiteCertificateAuthorityResponse {
#[serde(rename = "Certificate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate: Option<String>,
#[serde(rename = "CreatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_time: Option<f64>,
#[serde(rename = "DisplayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeviceSummary {
#[serde(rename = "DeviceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_id: Option<String>,
#[serde(rename = "DeviceStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_status: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisassociateDomainRequest {
#[serde(rename = "DomainName")]
pub domain_name: String,
#[serde(rename = "FleetArn")]
pub fleet_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisassociateDomainResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisassociateWebsiteAuthorizationProviderRequest {
#[serde(rename = "AuthorizationProviderId")]
pub authorization_provider_id: String,
#[serde(rename = "FleetArn")]
pub fleet_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisassociateWebsiteAuthorizationProviderResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisassociateWebsiteCertificateAuthorityRequest {
#[serde(rename = "FleetArn")]
pub fleet_arn: String,
#[serde(rename = "WebsiteCaId")]
pub website_ca_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisassociateWebsiteCertificateAuthorityResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DomainSummary {
#[serde(rename = "CreatedTime")]
pub created_time: f64,
#[serde(rename = "DisplayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(rename = "DomainName")]
pub domain_name: String,
#[serde(rename = "DomainStatus")]
pub domain_status: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FleetSummary {
#[serde(rename = "CompanyCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub company_code: Option<String>,
#[serde(rename = "CreatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_time: Option<f64>,
#[serde(rename = "DisplayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(rename = "FleetArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fleet_arn: Option<String>,
#[serde(rename = "FleetName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fleet_name: Option<String>,
#[serde(rename = "FleetStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fleet_status: Option<String>,
#[serde(rename = "LastUpdatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_time: Option<f64>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDevicesRequest {
#[serde(rename = "FleetArn")]
pub fleet_arn: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDevicesResponse {
#[serde(rename = "Devices")]
#[serde(skip_serializing_if = "Option::is_none")]
pub devices: Option<Vec<DeviceSummary>>,
#[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 ListDomainsRequest {
#[serde(rename = "FleetArn")]
pub fleet_arn: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDomainsResponse {
#[serde(rename = "Domains")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domains: Option<Vec<DomainSummary>>,
#[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 ListFleetsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListFleetsResponse {
#[serde(rename = "FleetSummaryList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fleet_summary_list: Option<Vec<FleetSummary>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceResponse {
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListWebsiteAuthorizationProvidersRequest {
#[serde(rename = "FleetArn")]
pub fleet_arn: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListWebsiteAuthorizationProvidersResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "WebsiteAuthorizationProviders")]
#[serde(skip_serializing_if = "Option::is_none")]
pub website_authorization_providers: Option<Vec<WebsiteAuthorizationProviderSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListWebsiteCertificateAuthoritiesRequest {
#[serde(rename = "FleetArn")]
pub fleet_arn: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListWebsiteCertificateAuthoritiesResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "WebsiteCertificateAuthorities")]
#[serde(skip_serializing_if = "Option::is_none")]
pub website_certificate_authorities: Option<Vec<WebsiteCaSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RestoreDomainAccessRequest {
#[serde(rename = "DomainName")]
pub domain_name: String,
#[serde(rename = "FleetArn")]
pub fleet_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RestoreDomainAccessResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RevokeDomainAccessRequest {
#[serde(rename = "DomainName")]
pub domain_name: String,
#[serde(rename = "FleetArn")]
pub fleet_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RevokeDomainAccessResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SignOutUserRequest {
#[serde(rename = "FleetArn")]
pub fleet_arn: String,
#[serde(rename = "Username")]
pub username: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SignOutUserResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "Tags")]
pub tags: ::std::collections::HashMap<String, String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TagResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UntagResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateAuditStreamConfigurationRequest {
#[serde(rename = "AuditStreamArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub audit_stream_arn: Option<String>,
#[serde(rename = "FleetArn")]
pub fleet_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateAuditStreamConfigurationResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateCompanyNetworkConfigurationRequest {
#[serde(rename = "FleetArn")]
pub fleet_arn: String,
#[serde(rename = "SecurityGroupIds")]
pub security_group_ids: Vec<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 UpdateCompanyNetworkConfigurationResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateDevicePolicyConfigurationRequest {
#[serde(rename = "DeviceCaCertificate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_ca_certificate: Option<String>,
#[serde(rename = "FleetArn")]
pub fleet_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateDevicePolicyConfigurationResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateDomainMetadataRequest {
#[serde(rename = "DisplayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(rename = "DomainName")]
pub domain_name: String,
#[serde(rename = "FleetArn")]
pub fleet_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateDomainMetadataResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateFleetMetadataRequest {
#[serde(rename = "DisplayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(rename = "FleetArn")]
pub fleet_arn: String,
#[serde(rename = "OptimizeForEndUserLocation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub optimize_for_end_user_location: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateFleetMetadataResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateIdentityProviderConfigurationRequest {
#[serde(rename = "FleetArn")]
pub fleet_arn: String,
#[serde(rename = "IdentityProviderSamlMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_provider_saml_metadata: Option<String>,
#[serde(rename = "IdentityProviderType")]
pub identity_provider_type: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateIdentityProviderConfigurationResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct WebsiteAuthorizationProviderSummary {
#[serde(rename = "AuthorizationProviderId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorization_provider_id: Option<String>,
#[serde(rename = "AuthorizationProviderType")]
pub authorization_provider_type: String,
#[serde(rename = "CreatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_time: Option<f64>,
#[serde(rename = "DomainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct WebsiteCaSummary {
#[serde(rename = "CreatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_time: Option<f64>,
#[serde(rename = "DisplayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(rename = "WebsiteCaId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub website_ca_id: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum AssociateDomainError {
InternalServerError(String),
InvalidRequest(String),
ResourceAlreadyExists(String),
ResourceNotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl AssociateDomainError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AssociateDomainError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(AssociateDomainError::InternalServerError(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(AssociateDomainError::InvalidRequest(err.msg))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(AssociateDomainError::ResourceAlreadyExists(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AssociateDomainError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(AssociateDomainError::TooManyRequests(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(AssociateDomainError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociateDomainError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociateDomainError::InternalServerError(ref cause) => write!(f, "{}", cause),
AssociateDomainError::InvalidRequest(ref cause) => write!(f, "{}", cause),
AssociateDomainError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
AssociateDomainError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AssociateDomainError::TooManyRequests(ref cause) => write!(f, "{}", cause),
AssociateDomainError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AssociateDomainError {}
#[derive(Debug, PartialEq)]
pub enum AssociateWebsiteAuthorizationProviderError {
InternalServerError(String),
InvalidRequest(String),
ResourceAlreadyExists(String),
ResourceNotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl AssociateWebsiteAuthorizationProviderError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AssociateWebsiteAuthorizationProviderError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(
AssociateWebsiteAuthorizationProviderError::InternalServerError(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
AssociateWebsiteAuthorizationProviderError::InvalidRequest(err.msg),
)
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(
AssociateWebsiteAuthorizationProviderError::ResourceAlreadyExists(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
AssociateWebsiteAuthorizationProviderError::ResourceNotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
AssociateWebsiteAuthorizationProviderError::TooManyRequests(err.msg),
)
}
"UnauthorizedException" => {
return RusotoError::Service(
AssociateWebsiteAuthorizationProviderError::Unauthorized(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociateWebsiteAuthorizationProviderError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociateWebsiteAuthorizationProviderError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
AssociateWebsiteAuthorizationProviderError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
AssociateWebsiteAuthorizationProviderError::ResourceAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
AssociateWebsiteAuthorizationProviderError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
AssociateWebsiteAuthorizationProviderError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
AssociateWebsiteAuthorizationProviderError::Unauthorized(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AssociateWebsiteAuthorizationProviderError {}
#[derive(Debug, PartialEq)]
pub enum AssociateWebsiteCertificateAuthorityError {
InternalServerError(String),
InvalidRequest(String),
ResourceAlreadyExists(String),
ResourceNotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl AssociateWebsiteCertificateAuthorityError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AssociateWebsiteCertificateAuthorityError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(
AssociateWebsiteCertificateAuthorityError::InternalServerError(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
AssociateWebsiteCertificateAuthorityError::InvalidRequest(err.msg),
)
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(
AssociateWebsiteCertificateAuthorityError::ResourceAlreadyExists(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
AssociateWebsiteCertificateAuthorityError::ResourceNotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
AssociateWebsiteCertificateAuthorityError::TooManyRequests(err.msg),
)
}
"UnauthorizedException" => {
return RusotoError::Service(
AssociateWebsiteCertificateAuthorityError::Unauthorized(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociateWebsiteCertificateAuthorityError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociateWebsiteCertificateAuthorityError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
AssociateWebsiteCertificateAuthorityError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
AssociateWebsiteCertificateAuthorityError::ResourceAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
AssociateWebsiteCertificateAuthorityError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
AssociateWebsiteCertificateAuthorityError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
AssociateWebsiteCertificateAuthorityError::Unauthorized(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AssociateWebsiteCertificateAuthorityError {}
#[derive(Debug, PartialEq)]
pub enum CreateFleetError {
InternalServerError(String),
InvalidRequest(String),
ResourceAlreadyExists(String),
ResourceNotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl CreateFleetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateFleetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(CreateFleetError::InternalServerError(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateFleetError::InvalidRequest(err.msg))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(CreateFleetError::ResourceAlreadyExists(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateFleetError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateFleetError::TooManyRequests(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(CreateFleetError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateFleetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateFleetError::InternalServerError(ref cause) => write!(f, "{}", cause),
CreateFleetError::InvalidRequest(ref cause) => write!(f, "{}", cause),
CreateFleetError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateFleetError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateFleetError::TooManyRequests(ref cause) => write!(f, "{}", cause),
CreateFleetError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateFleetError {}
#[derive(Debug, PartialEq)]
pub enum DeleteFleetError {
InternalServerError(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl DeleteFleetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteFleetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(DeleteFleetError::InternalServerError(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteFleetError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteFleetError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteFleetError::TooManyRequests(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(DeleteFleetError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteFleetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteFleetError::InternalServerError(ref cause) => write!(f, "{}", cause),
DeleteFleetError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeleteFleetError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteFleetError::TooManyRequests(ref cause) => write!(f, "{}", cause),
DeleteFleetError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteFleetError {}
#[derive(Debug, PartialEq)]
pub enum DescribeAuditStreamConfigurationError {
InternalServerError(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl DescribeAuditStreamConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeAuditStreamConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(
DescribeAuditStreamConfigurationError::InternalServerError(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
DescribeAuditStreamConfigurationError::InvalidRequest(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DescribeAuditStreamConfigurationError::ResourceNotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
DescribeAuditStreamConfigurationError::TooManyRequests(err.msg),
)
}
"UnauthorizedException" => {
return RusotoError::Service(
DescribeAuditStreamConfigurationError::Unauthorized(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeAuditStreamConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeAuditStreamConfigurationError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
DescribeAuditStreamConfigurationError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
DescribeAuditStreamConfigurationError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
DescribeAuditStreamConfigurationError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
DescribeAuditStreamConfigurationError::Unauthorized(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeAuditStreamConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum DescribeCompanyNetworkConfigurationError {
InternalServerError(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl DescribeCompanyNetworkConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeCompanyNetworkConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(
DescribeCompanyNetworkConfigurationError::InternalServerError(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
DescribeCompanyNetworkConfigurationError::InvalidRequest(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DescribeCompanyNetworkConfigurationError::ResourceNotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
DescribeCompanyNetworkConfigurationError::TooManyRequests(err.msg),
)
}
"UnauthorizedException" => {
return RusotoError::Service(
DescribeCompanyNetworkConfigurationError::Unauthorized(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeCompanyNetworkConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeCompanyNetworkConfigurationError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
DescribeCompanyNetworkConfigurationError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
DescribeCompanyNetworkConfigurationError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
DescribeCompanyNetworkConfigurationError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
DescribeCompanyNetworkConfigurationError::Unauthorized(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeCompanyNetworkConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum DescribeDeviceError {
InternalServerError(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl DescribeDeviceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeDeviceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(DescribeDeviceError::InternalServerError(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DescribeDeviceError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeDeviceError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DescribeDeviceError::TooManyRequests(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(DescribeDeviceError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeDeviceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeDeviceError::InternalServerError(ref cause) => write!(f, "{}", cause),
DescribeDeviceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DescribeDeviceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeDeviceError::TooManyRequests(ref cause) => write!(f, "{}", cause),
DescribeDeviceError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeDeviceError {}
#[derive(Debug, PartialEq)]
pub enum DescribeDevicePolicyConfigurationError {
InternalServerError(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl DescribeDevicePolicyConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeDevicePolicyConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(
DescribeDevicePolicyConfigurationError::InternalServerError(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
DescribeDevicePolicyConfigurationError::InvalidRequest(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DescribeDevicePolicyConfigurationError::ResourceNotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
DescribeDevicePolicyConfigurationError::TooManyRequests(err.msg),
)
}
"UnauthorizedException" => {
return RusotoError::Service(
DescribeDevicePolicyConfigurationError::Unauthorized(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeDevicePolicyConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeDevicePolicyConfigurationError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
DescribeDevicePolicyConfigurationError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
DescribeDevicePolicyConfigurationError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
DescribeDevicePolicyConfigurationError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
DescribeDevicePolicyConfigurationError::Unauthorized(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeDevicePolicyConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum DescribeDomainError {
InternalServerError(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl DescribeDomainError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeDomainError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(DescribeDomainError::InternalServerError(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DescribeDomainError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeDomainError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DescribeDomainError::TooManyRequests(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(DescribeDomainError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeDomainError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeDomainError::InternalServerError(ref cause) => write!(f, "{}", cause),
DescribeDomainError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DescribeDomainError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeDomainError::TooManyRequests(ref cause) => write!(f, "{}", cause),
DescribeDomainError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeDomainError {}
#[derive(Debug, PartialEq)]
pub enum DescribeFleetMetadataError {
InternalServerError(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl DescribeFleetMetadataError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeFleetMetadataError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(DescribeFleetMetadataError::InternalServerError(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(DescribeFleetMetadataError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeFleetMetadataError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(DescribeFleetMetadataError::TooManyRequests(
err.msg,
))
}
"UnauthorizedException" => {
return RusotoError::Service(DescribeFleetMetadataError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeFleetMetadataError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeFleetMetadataError::InternalServerError(ref cause) => write!(f, "{}", cause),
DescribeFleetMetadataError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DescribeFleetMetadataError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeFleetMetadataError::TooManyRequests(ref cause) => write!(f, "{}", cause),
DescribeFleetMetadataError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeFleetMetadataError {}
#[derive(Debug, PartialEq)]
pub enum DescribeIdentityProviderConfigurationError {
InternalServerError(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl DescribeIdentityProviderConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeIdentityProviderConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(
DescribeIdentityProviderConfigurationError::InternalServerError(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
DescribeIdentityProviderConfigurationError::InvalidRequest(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DescribeIdentityProviderConfigurationError::ResourceNotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
DescribeIdentityProviderConfigurationError::TooManyRequests(err.msg),
)
}
"UnauthorizedException" => {
return RusotoError::Service(
DescribeIdentityProviderConfigurationError::Unauthorized(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeIdentityProviderConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeIdentityProviderConfigurationError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
DescribeIdentityProviderConfigurationError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
DescribeIdentityProviderConfigurationError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
DescribeIdentityProviderConfigurationError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
DescribeIdentityProviderConfigurationError::Unauthorized(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeIdentityProviderConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum DescribeWebsiteCertificateAuthorityError {
InternalServerError(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl DescribeWebsiteCertificateAuthorityError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeWebsiteCertificateAuthorityError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(
DescribeWebsiteCertificateAuthorityError::InternalServerError(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
DescribeWebsiteCertificateAuthorityError::InvalidRequest(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DescribeWebsiteCertificateAuthorityError::ResourceNotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
DescribeWebsiteCertificateAuthorityError::TooManyRequests(err.msg),
)
}
"UnauthorizedException" => {
return RusotoError::Service(
DescribeWebsiteCertificateAuthorityError::Unauthorized(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeWebsiteCertificateAuthorityError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeWebsiteCertificateAuthorityError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
DescribeWebsiteCertificateAuthorityError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
DescribeWebsiteCertificateAuthorityError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
DescribeWebsiteCertificateAuthorityError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
DescribeWebsiteCertificateAuthorityError::Unauthorized(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeWebsiteCertificateAuthorityError {}
#[derive(Debug, PartialEq)]
pub enum DisassociateDomainError {
InternalServerError(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl DisassociateDomainError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DisassociateDomainError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(DisassociateDomainError::InternalServerError(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(DisassociateDomainError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DisassociateDomainError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DisassociateDomainError::TooManyRequests(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(DisassociateDomainError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisassociateDomainError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisassociateDomainError::InternalServerError(ref cause) => write!(f, "{}", cause),
DisassociateDomainError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DisassociateDomainError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DisassociateDomainError::TooManyRequests(ref cause) => write!(f, "{}", cause),
DisassociateDomainError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DisassociateDomainError {}
#[derive(Debug, PartialEq)]
pub enum DisassociateWebsiteAuthorizationProviderError {
InternalServerError(String),
InvalidRequest(String),
ResourceAlreadyExists(String),
ResourceNotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl DisassociateWebsiteAuthorizationProviderError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisassociateWebsiteAuthorizationProviderError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(
DisassociateWebsiteAuthorizationProviderError::InternalServerError(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
DisassociateWebsiteAuthorizationProviderError::InvalidRequest(err.msg),
)
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(
DisassociateWebsiteAuthorizationProviderError::ResourceAlreadyExists(
err.msg,
),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DisassociateWebsiteAuthorizationProviderError::ResourceNotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
DisassociateWebsiteAuthorizationProviderError::TooManyRequests(err.msg),
)
}
"UnauthorizedException" => {
return RusotoError::Service(
DisassociateWebsiteAuthorizationProviderError::Unauthorized(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisassociateWebsiteAuthorizationProviderError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisassociateWebsiteAuthorizationProviderError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
DisassociateWebsiteAuthorizationProviderError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
DisassociateWebsiteAuthorizationProviderError::ResourceAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
DisassociateWebsiteAuthorizationProviderError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
DisassociateWebsiteAuthorizationProviderError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
DisassociateWebsiteAuthorizationProviderError::Unauthorized(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DisassociateWebsiteAuthorizationProviderError {}
#[derive(Debug, PartialEq)]
pub enum DisassociateWebsiteCertificateAuthorityError {
InternalServerError(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl DisassociateWebsiteCertificateAuthorityError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisassociateWebsiteCertificateAuthorityError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(
DisassociateWebsiteCertificateAuthorityError::InternalServerError(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
DisassociateWebsiteCertificateAuthorityError::InvalidRequest(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DisassociateWebsiteCertificateAuthorityError::ResourceNotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
DisassociateWebsiteCertificateAuthorityError::TooManyRequests(err.msg),
)
}
"UnauthorizedException" => {
return RusotoError::Service(
DisassociateWebsiteCertificateAuthorityError::Unauthorized(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisassociateWebsiteCertificateAuthorityError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisassociateWebsiteCertificateAuthorityError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
DisassociateWebsiteCertificateAuthorityError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
DisassociateWebsiteCertificateAuthorityError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
DisassociateWebsiteCertificateAuthorityError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
DisassociateWebsiteCertificateAuthorityError::Unauthorized(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DisassociateWebsiteCertificateAuthorityError {}
#[derive(Debug, PartialEq)]
pub enum ListDevicesError {
InternalServerError(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl ListDevicesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDevicesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(ListDevicesError::InternalServerError(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListDevicesError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListDevicesError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListDevicesError::TooManyRequests(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(ListDevicesError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDevicesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDevicesError::InternalServerError(ref cause) => write!(f, "{}", cause),
ListDevicesError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListDevicesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListDevicesError::TooManyRequests(ref cause) => write!(f, "{}", cause),
ListDevicesError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDevicesError {}
#[derive(Debug, PartialEq)]
pub enum ListDomainsError {
InternalServerError(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl ListDomainsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDomainsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(ListDomainsError::InternalServerError(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListDomainsError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListDomainsError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListDomainsError::TooManyRequests(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(ListDomainsError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDomainsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDomainsError::InternalServerError(ref cause) => write!(f, "{}", cause),
ListDomainsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListDomainsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListDomainsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
ListDomainsError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDomainsError {}
#[derive(Debug, PartialEq)]
pub enum ListFleetsError {
InternalServerError(String),
InvalidRequest(String),
TooManyRequests(String),
Unauthorized(String),
}
impl ListFleetsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListFleetsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(ListFleetsError::InternalServerError(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListFleetsError::InvalidRequest(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListFleetsError::TooManyRequests(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(ListFleetsError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListFleetsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListFleetsError::InternalServerError(ref cause) => write!(f, "{}", cause),
ListFleetsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListFleetsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
ListFleetsError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListFleetsError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
InvalidRequest(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidRequestException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidRequest(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::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum ListWebsiteAuthorizationProvidersError {
InternalServerError(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl ListWebsiteAuthorizationProvidersError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListWebsiteAuthorizationProvidersError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(
ListWebsiteAuthorizationProvidersError::InternalServerError(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
ListWebsiteAuthorizationProvidersError::InvalidRequest(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
ListWebsiteAuthorizationProvidersError::ResourceNotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
ListWebsiteAuthorizationProvidersError::TooManyRequests(err.msg),
)
}
"UnauthorizedException" => {
return RusotoError::Service(
ListWebsiteAuthorizationProvidersError::Unauthorized(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListWebsiteAuthorizationProvidersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListWebsiteAuthorizationProvidersError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
ListWebsiteAuthorizationProvidersError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
ListWebsiteAuthorizationProvidersError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
ListWebsiteAuthorizationProvidersError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
ListWebsiteAuthorizationProvidersError::Unauthorized(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListWebsiteAuthorizationProvidersError {}
#[derive(Debug, PartialEq)]
pub enum ListWebsiteCertificateAuthoritiesError {
InternalServerError(String),
InvalidRequest(String),
TooManyRequests(String),
Unauthorized(String),
}
impl ListWebsiteCertificateAuthoritiesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListWebsiteCertificateAuthoritiesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(
ListWebsiteCertificateAuthoritiesError::InternalServerError(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
ListWebsiteCertificateAuthoritiesError::InvalidRequest(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
ListWebsiteCertificateAuthoritiesError::TooManyRequests(err.msg),
)
}
"UnauthorizedException" => {
return RusotoError::Service(
ListWebsiteCertificateAuthoritiesError::Unauthorized(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListWebsiteCertificateAuthoritiesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListWebsiteCertificateAuthoritiesError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
ListWebsiteCertificateAuthoritiesError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
ListWebsiteCertificateAuthoritiesError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
ListWebsiteCertificateAuthoritiesError::Unauthorized(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListWebsiteCertificateAuthoritiesError {}
#[derive(Debug, PartialEq)]
pub enum RestoreDomainAccessError {
InternalServerError(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl RestoreDomainAccessError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RestoreDomainAccessError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(RestoreDomainAccessError::InternalServerError(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(RestoreDomainAccessError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(RestoreDomainAccessError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(RestoreDomainAccessError::TooManyRequests(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(RestoreDomainAccessError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RestoreDomainAccessError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RestoreDomainAccessError::InternalServerError(ref cause) => write!(f, "{}", cause),
RestoreDomainAccessError::InvalidRequest(ref cause) => write!(f, "{}", cause),
RestoreDomainAccessError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
RestoreDomainAccessError::TooManyRequests(ref cause) => write!(f, "{}", cause),
RestoreDomainAccessError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RestoreDomainAccessError {}
#[derive(Debug, PartialEq)]
pub enum RevokeDomainAccessError {
InternalServerError(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl RevokeDomainAccessError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RevokeDomainAccessError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(RevokeDomainAccessError::InternalServerError(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(RevokeDomainAccessError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(RevokeDomainAccessError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(RevokeDomainAccessError::TooManyRequests(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(RevokeDomainAccessError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RevokeDomainAccessError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RevokeDomainAccessError::InternalServerError(ref cause) => write!(f, "{}", cause),
RevokeDomainAccessError::InvalidRequest(ref cause) => write!(f, "{}", cause),
RevokeDomainAccessError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
RevokeDomainAccessError::TooManyRequests(ref cause) => write!(f, "{}", cause),
RevokeDomainAccessError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RevokeDomainAccessError {}
#[derive(Debug, PartialEq)]
pub enum SignOutUserError {
InternalServerError(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl SignOutUserError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SignOutUserError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(SignOutUserError::InternalServerError(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(SignOutUserError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(SignOutUserError::ResourceNotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(SignOutUserError::TooManyRequests(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(SignOutUserError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SignOutUserError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SignOutUserError::InternalServerError(ref cause) => write!(f, "{}", cause),
SignOutUserError::InvalidRequest(ref cause) => write!(f, "{}", cause),
SignOutUserError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
SignOutUserError::TooManyRequests(ref cause) => write!(f, "{}", cause),
SignOutUserError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SignOutUserError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
InvalidRequest(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidRequestException" => {
return RusotoError::Service(TagResourceError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagResourceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
InvalidRequest(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidRequestException" => {
return RusotoError::Service(UntagResourceError::InvalidRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UntagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UntagResourceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateAuditStreamConfigurationError {
InternalServerError(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl UpdateAuditStreamConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateAuditStreamConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(
UpdateAuditStreamConfigurationError::InternalServerError(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
UpdateAuditStreamConfigurationError::InvalidRequest(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
UpdateAuditStreamConfigurationError::ResourceNotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
UpdateAuditStreamConfigurationError::TooManyRequests(err.msg),
)
}
"UnauthorizedException" => {
return RusotoError::Service(UpdateAuditStreamConfigurationError::Unauthorized(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateAuditStreamConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateAuditStreamConfigurationError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
UpdateAuditStreamConfigurationError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
UpdateAuditStreamConfigurationError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
UpdateAuditStreamConfigurationError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
UpdateAuditStreamConfigurationError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateAuditStreamConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum UpdateCompanyNetworkConfigurationError {
InternalServerError(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl UpdateCompanyNetworkConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateCompanyNetworkConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(
UpdateCompanyNetworkConfigurationError::InternalServerError(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
UpdateCompanyNetworkConfigurationError::InvalidRequest(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
UpdateCompanyNetworkConfigurationError::ResourceNotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
UpdateCompanyNetworkConfigurationError::TooManyRequests(err.msg),
)
}
"UnauthorizedException" => {
return RusotoError::Service(
UpdateCompanyNetworkConfigurationError::Unauthorized(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateCompanyNetworkConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateCompanyNetworkConfigurationError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
UpdateCompanyNetworkConfigurationError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
UpdateCompanyNetworkConfigurationError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
UpdateCompanyNetworkConfigurationError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
UpdateCompanyNetworkConfigurationError::Unauthorized(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateCompanyNetworkConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum UpdateDevicePolicyConfigurationError {
InternalServerError(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl UpdateDevicePolicyConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateDevicePolicyConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(
UpdateDevicePolicyConfigurationError::InternalServerError(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
UpdateDevicePolicyConfigurationError::InvalidRequest(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
UpdateDevicePolicyConfigurationError::ResourceNotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
UpdateDevicePolicyConfigurationError::TooManyRequests(err.msg),
)
}
"UnauthorizedException" => {
return RusotoError::Service(
UpdateDevicePolicyConfigurationError::Unauthorized(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateDevicePolicyConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateDevicePolicyConfigurationError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
UpdateDevicePolicyConfigurationError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
UpdateDevicePolicyConfigurationError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
UpdateDevicePolicyConfigurationError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
UpdateDevicePolicyConfigurationError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateDevicePolicyConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum UpdateDomainMetadataError {
InternalServerError(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl UpdateDomainMetadataError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateDomainMetadataError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(UpdateDomainMetadataError::InternalServerError(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(UpdateDomainMetadataError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateDomainMetadataError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateDomainMetadataError::TooManyRequests(
err.msg,
))
}
"UnauthorizedException" => {
return RusotoError::Service(UpdateDomainMetadataError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateDomainMetadataError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateDomainMetadataError::InternalServerError(ref cause) => write!(f, "{}", cause),
UpdateDomainMetadataError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UpdateDomainMetadataError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateDomainMetadataError::TooManyRequests(ref cause) => write!(f, "{}", cause),
UpdateDomainMetadataError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateDomainMetadataError {}
#[derive(Debug, PartialEq)]
pub enum UpdateFleetMetadataError {
InternalServerError(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl UpdateFleetMetadataError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateFleetMetadataError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(UpdateFleetMetadataError::InternalServerError(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(UpdateFleetMetadataError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateFleetMetadataError::ResourceNotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateFleetMetadataError::TooManyRequests(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(UpdateFleetMetadataError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateFleetMetadataError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateFleetMetadataError::InternalServerError(ref cause) => write!(f, "{}", cause),
UpdateFleetMetadataError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UpdateFleetMetadataError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateFleetMetadataError::TooManyRequests(ref cause) => write!(f, "{}", cause),
UpdateFleetMetadataError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateFleetMetadataError {}
#[derive(Debug, PartialEq)]
pub enum UpdateIdentityProviderConfigurationError {
InternalServerError(String),
InvalidRequest(String),
ResourceNotFound(String),
TooManyRequests(String),
Unauthorized(String),
}
impl UpdateIdentityProviderConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateIdentityProviderConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(
UpdateIdentityProviderConfigurationError::InternalServerError(err.msg),
)
}
"InvalidRequestException" => {
return RusotoError::Service(
UpdateIdentityProviderConfigurationError::InvalidRequest(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
UpdateIdentityProviderConfigurationError::ResourceNotFound(err.msg),
)
}
"TooManyRequestsException" => {
return RusotoError::Service(
UpdateIdentityProviderConfigurationError::TooManyRequests(err.msg),
)
}
"UnauthorizedException" => {
return RusotoError::Service(
UpdateIdentityProviderConfigurationError::Unauthorized(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateIdentityProviderConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateIdentityProviderConfigurationError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
UpdateIdentityProviderConfigurationError::InvalidRequest(ref cause) => {
write!(f, "{}", cause)
}
UpdateIdentityProviderConfigurationError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
UpdateIdentityProviderConfigurationError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
UpdateIdentityProviderConfigurationError::Unauthorized(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateIdentityProviderConfigurationError {}
#[async_trait]
pub trait Worklink {
async fn associate_domain(
&self,
input: AssociateDomainRequest,
) -> Result<AssociateDomainResponse, RusotoError<AssociateDomainError>>;
async fn associate_website_authorization_provider(
&self,
input: AssociateWebsiteAuthorizationProviderRequest,
) -> Result<
AssociateWebsiteAuthorizationProviderResponse,
RusotoError<AssociateWebsiteAuthorizationProviderError>,
>;
async fn associate_website_certificate_authority(
&self,
input: AssociateWebsiteCertificateAuthorityRequest,
) -> Result<
AssociateWebsiteCertificateAuthorityResponse,
RusotoError<AssociateWebsiteCertificateAuthorityError>,
>;
async fn create_fleet(
&self,
input: CreateFleetRequest,
) -> Result<CreateFleetResponse, RusotoError<CreateFleetError>>;
async fn delete_fleet(
&self,
input: DeleteFleetRequest,
) -> Result<DeleteFleetResponse, RusotoError<DeleteFleetError>>;
async fn describe_audit_stream_configuration(
&self,
input: DescribeAuditStreamConfigurationRequest,
) -> Result<
DescribeAuditStreamConfigurationResponse,
RusotoError<DescribeAuditStreamConfigurationError>,
>;
async fn describe_company_network_configuration(
&self,
input: DescribeCompanyNetworkConfigurationRequest,
) -> Result<
DescribeCompanyNetworkConfigurationResponse,
RusotoError<DescribeCompanyNetworkConfigurationError>,
>;
async fn describe_device(
&self,
input: DescribeDeviceRequest,
) -> Result<DescribeDeviceResponse, RusotoError<DescribeDeviceError>>;
async fn describe_device_policy_configuration(
&self,
input: DescribeDevicePolicyConfigurationRequest,
) -> Result<
DescribeDevicePolicyConfigurationResponse,
RusotoError<DescribeDevicePolicyConfigurationError>,
>;
async fn describe_domain(
&self,
input: DescribeDomainRequest,
) -> Result<DescribeDomainResponse, RusotoError<DescribeDomainError>>;
async fn describe_fleet_metadata(
&self,
input: DescribeFleetMetadataRequest,
) -> Result<DescribeFleetMetadataResponse, RusotoError<DescribeFleetMetadataError>>;
async fn describe_identity_provider_configuration(
&self,
input: DescribeIdentityProviderConfigurationRequest,
) -> Result<
DescribeIdentityProviderConfigurationResponse,
RusotoError<DescribeIdentityProviderConfigurationError>,
>;
async fn describe_website_certificate_authority(
&self,
input: DescribeWebsiteCertificateAuthorityRequest,
) -> Result<
DescribeWebsiteCertificateAuthorityResponse,
RusotoError<DescribeWebsiteCertificateAuthorityError>,
>;
async fn disassociate_domain(
&self,
input: DisassociateDomainRequest,
) -> Result<DisassociateDomainResponse, RusotoError<DisassociateDomainError>>;
async fn disassociate_website_authorization_provider(
&self,
input: DisassociateWebsiteAuthorizationProviderRequest,
) -> Result<
DisassociateWebsiteAuthorizationProviderResponse,
RusotoError<DisassociateWebsiteAuthorizationProviderError>,
>;
async fn disassociate_website_certificate_authority(
&self,
input: DisassociateWebsiteCertificateAuthorityRequest,
) -> Result<
DisassociateWebsiteCertificateAuthorityResponse,
RusotoError<DisassociateWebsiteCertificateAuthorityError>,
>;
async fn list_devices(
&self,
input: ListDevicesRequest,
) -> Result<ListDevicesResponse, RusotoError<ListDevicesError>>;
async fn list_domains(
&self,
input: ListDomainsRequest,
) -> Result<ListDomainsResponse, RusotoError<ListDomainsError>>;
async fn list_fleets(
&self,
input: ListFleetsRequest,
) -> Result<ListFleetsResponse, RusotoError<ListFleetsError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
async fn list_website_authorization_providers(
&self,
input: ListWebsiteAuthorizationProvidersRequest,
) -> Result<
ListWebsiteAuthorizationProvidersResponse,
RusotoError<ListWebsiteAuthorizationProvidersError>,
>;
async fn list_website_certificate_authorities(
&self,
input: ListWebsiteCertificateAuthoritiesRequest,
) -> Result<
ListWebsiteCertificateAuthoritiesResponse,
RusotoError<ListWebsiteCertificateAuthoritiesError>,
>;
async fn restore_domain_access(
&self,
input: RestoreDomainAccessRequest,
) -> Result<RestoreDomainAccessResponse, RusotoError<RestoreDomainAccessError>>;
async fn revoke_domain_access(
&self,
input: RevokeDomainAccessRequest,
) -> Result<RevokeDomainAccessResponse, RusotoError<RevokeDomainAccessError>>;
async fn sign_out_user(
&self,
input: SignOutUserRequest,
) -> Result<SignOutUserResponse, RusotoError<SignOutUserError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>>;
async fn update_audit_stream_configuration(
&self,
input: UpdateAuditStreamConfigurationRequest,
) -> Result<
UpdateAuditStreamConfigurationResponse,
RusotoError<UpdateAuditStreamConfigurationError>,
>;
async fn update_company_network_configuration(
&self,
input: UpdateCompanyNetworkConfigurationRequest,
) -> Result<
UpdateCompanyNetworkConfigurationResponse,
RusotoError<UpdateCompanyNetworkConfigurationError>,
>;
async fn update_device_policy_configuration(
&self,
input: UpdateDevicePolicyConfigurationRequest,
) -> Result<
UpdateDevicePolicyConfigurationResponse,
RusotoError<UpdateDevicePolicyConfigurationError>,
>;
async fn update_domain_metadata(
&self,
input: UpdateDomainMetadataRequest,
) -> Result<UpdateDomainMetadataResponse, RusotoError<UpdateDomainMetadataError>>;
async fn update_fleet_metadata(
&self,
input: UpdateFleetMetadataRequest,
) -> Result<UpdateFleetMetadataResponse, RusotoError<UpdateFleetMetadataError>>;
async fn update_identity_provider_configuration(
&self,
input: UpdateIdentityProviderConfigurationRequest,
) -> Result<
UpdateIdentityProviderConfigurationResponse,
RusotoError<UpdateIdentityProviderConfigurationError>,
>;
}
#[derive(Clone)]
pub struct WorklinkClient {
client: Client,
region: region::Region,
}
impl WorklinkClient {
pub fn new(region: region::Region) -> WorklinkClient {
WorklinkClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> WorklinkClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
WorklinkClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> WorklinkClient {
WorklinkClient { client, region }
}
}
#[async_trait]
impl Worklink for WorklinkClient {
#[allow(unused_mut)]
async fn associate_domain(
&self,
input: AssociateDomainRequest,
) -> Result<AssociateDomainResponse, RusotoError<AssociateDomainError>> {
let request_uri = "/associateDomain";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<AssociateDomainResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(AssociateDomainError::from_response(response))
}
}
#[allow(unused_mut)]
async fn associate_website_authorization_provider(
&self,
input: AssociateWebsiteAuthorizationProviderRequest,
) -> Result<
AssociateWebsiteAuthorizationProviderResponse,
RusotoError<AssociateWebsiteAuthorizationProviderError>,
> {
let request_uri = "/associateWebsiteAuthorizationProvider";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<AssociateWebsiteAuthorizationProviderResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(AssociateWebsiteAuthorizationProviderError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn associate_website_certificate_authority(
&self,
input: AssociateWebsiteCertificateAuthorityRequest,
) -> Result<
AssociateWebsiteCertificateAuthorityResponse,
RusotoError<AssociateWebsiteCertificateAuthorityError>,
> {
let request_uri = "/associateWebsiteCertificateAuthority";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<AssociateWebsiteCertificateAuthorityResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(AssociateWebsiteCertificateAuthorityError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn create_fleet(
&self,
input: CreateFleetRequest,
) -> Result<CreateFleetResponse, RusotoError<CreateFleetError>> {
let request_uri = "/createFleet";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateFleetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateFleetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_fleet(
&self,
input: DeleteFleetRequest,
) -> Result<DeleteFleetResponse, RusotoError<DeleteFleetError>> {
let request_uri = "/deleteFleet";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteFleetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteFleetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_audit_stream_configuration(
&self,
input: DescribeAuditStreamConfigurationRequest,
) -> Result<
DescribeAuditStreamConfigurationResponse,
RusotoError<DescribeAuditStreamConfigurationError>,
> {
let request_uri = "/describeAuditStreamConfiguration";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeAuditStreamConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeAuditStreamConfigurationError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn describe_company_network_configuration(
&self,
input: DescribeCompanyNetworkConfigurationRequest,
) -> Result<
DescribeCompanyNetworkConfigurationResponse,
RusotoError<DescribeCompanyNetworkConfigurationError>,
> {
let request_uri = "/describeCompanyNetworkConfiguration";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeCompanyNetworkConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeCompanyNetworkConfigurationError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn describe_device(
&self,
input: DescribeDeviceRequest,
) -> Result<DescribeDeviceResponse, RusotoError<DescribeDeviceError>> {
let request_uri = "/describeDevice";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeDeviceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeDeviceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_device_policy_configuration(
&self,
input: DescribeDevicePolicyConfigurationRequest,
) -> Result<
DescribeDevicePolicyConfigurationResponse,
RusotoError<DescribeDevicePolicyConfigurationError>,
> {
let request_uri = "/describeDevicePolicyConfiguration";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeDevicePolicyConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeDevicePolicyConfigurationError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn describe_domain(
&self,
input: DescribeDomainRequest,
) -> Result<DescribeDomainResponse, RusotoError<DescribeDomainError>> {
let request_uri = "/describeDomain";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeDomainResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeDomainError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_fleet_metadata(
&self,
input: DescribeFleetMetadataRequest,
) -> Result<DescribeFleetMetadataResponse, RusotoError<DescribeFleetMetadataError>> {
let request_uri = "/describeFleetMetadata";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeFleetMetadataResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeFleetMetadataError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_identity_provider_configuration(
&self,
input: DescribeIdentityProviderConfigurationRequest,
) -> Result<
DescribeIdentityProviderConfigurationResponse,
RusotoError<DescribeIdentityProviderConfigurationError>,
> {
let request_uri = "/describeIdentityProviderConfiguration";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeIdentityProviderConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeIdentityProviderConfigurationError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn describe_website_certificate_authority(
&self,
input: DescribeWebsiteCertificateAuthorityRequest,
) -> Result<
DescribeWebsiteCertificateAuthorityResponse,
RusotoError<DescribeWebsiteCertificateAuthorityError>,
> {
let request_uri = "/describeWebsiteCertificateAuthority";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeWebsiteCertificateAuthorityResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeWebsiteCertificateAuthorityError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn disassociate_domain(
&self,
input: DisassociateDomainRequest,
) -> Result<DisassociateDomainResponse, RusotoError<DisassociateDomainError>> {
let request_uri = "/disassociateDomain";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DisassociateDomainResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DisassociateDomainError::from_response(response))
}
}
#[allow(unused_mut)]
async fn disassociate_website_authorization_provider(
&self,
input: DisassociateWebsiteAuthorizationProviderRequest,
) -> Result<
DisassociateWebsiteAuthorizationProviderResponse,
RusotoError<DisassociateWebsiteAuthorizationProviderError>,
> {
let request_uri = "/disassociateWebsiteAuthorizationProvider";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DisassociateWebsiteAuthorizationProviderResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DisassociateWebsiteAuthorizationProviderError::from_response(response))
}
}
#[allow(unused_mut)]
async fn disassociate_website_certificate_authority(
&self,
input: DisassociateWebsiteCertificateAuthorityRequest,
) -> Result<
DisassociateWebsiteCertificateAuthorityResponse,
RusotoError<DisassociateWebsiteCertificateAuthorityError>,
> {
let request_uri = "/disassociateWebsiteCertificateAuthority";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DisassociateWebsiteCertificateAuthorityResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DisassociateWebsiteCertificateAuthorityError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn list_devices(
&self,
input: ListDevicesRequest,
) -> Result<ListDevicesResponse, RusotoError<ListDevicesError>> {
let request_uri = "/listDevices";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListDevicesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListDevicesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_domains(
&self,
input: ListDomainsRequest,
) -> Result<ListDomainsResponse, RusotoError<ListDomainsError>> {
let request_uri = "/listDomains";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListDomainsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListDomainsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_fleets(
&self,
input: ListFleetsRequest,
) -> Result<ListFleetsResponse, RusotoError<ListFleetsError>> {
let request_uri = "/listFleets";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListFleetsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListFleetsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("GET", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListTagsForResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListTagsForResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_website_authorization_providers(
&self,
input: ListWebsiteAuthorizationProvidersRequest,
) -> Result<
ListWebsiteAuthorizationProvidersResponse,
RusotoError<ListWebsiteAuthorizationProvidersError>,
> {
let request_uri = "/listWebsiteAuthorizationProviders";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListWebsiteAuthorizationProvidersResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListWebsiteAuthorizationProvidersError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn list_website_certificate_authorities(
&self,
input: ListWebsiteCertificateAuthoritiesRequest,
) -> Result<
ListWebsiteCertificateAuthoritiesResponse,
RusotoError<ListWebsiteCertificateAuthoritiesError>,
> {
let request_uri = "/listWebsiteCertificateAuthorities";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListWebsiteCertificateAuthoritiesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListWebsiteCertificateAuthoritiesError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn restore_domain_access(
&self,
input: RestoreDomainAccessRequest,
) -> Result<RestoreDomainAccessResponse, RusotoError<RestoreDomainAccessError>> {
let request_uri = "/restoreDomainAccess";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<RestoreDomainAccessResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(RestoreDomainAccessError::from_response(response))
}
}
#[allow(unused_mut)]
async fn revoke_domain_access(
&self,
input: RevokeDomainAccessRequest,
) -> Result<RevokeDomainAccessResponse, RusotoError<RevokeDomainAccessError>> {
let request_uri = "/revokeDomainAccess";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<RevokeDomainAccessResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(RevokeDomainAccessError::from_response(response))
}
}
#[allow(unused_mut)]
async fn sign_out_user(
&self,
input: SignOutUserRequest,
) -> Result<SignOutUserResponse, RusotoError<SignOutUserError>> {
let request_uri = "/signOutUser";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<SignOutUserResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(SignOutUserError::from_response(response))
}
}
#[allow(unused_mut)]
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<TagResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(TagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("DELETE", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let mut params = Params::new();
for item in input.tag_keys.iter() {
params.put("tagKeys", item);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UntagResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UntagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_audit_stream_configuration(
&self,
input: UpdateAuditStreamConfigurationRequest,
) -> Result<
UpdateAuditStreamConfigurationResponse,
RusotoError<UpdateAuditStreamConfigurationError>,
> {
let request_uri = "/updateAuditStreamConfiguration";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateAuditStreamConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateAuditStreamConfigurationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_company_network_configuration(
&self,
input: UpdateCompanyNetworkConfigurationRequest,
) -> Result<
UpdateCompanyNetworkConfigurationResponse,
RusotoError<UpdateCompanyNetworkConfigurationError>,
> {
let request_uri = "/updateCompanyNetworkConfiguration";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateCompanyNetworkConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateCompanyNetworkConfigurationError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn update_device_policy_configuration(
&self,
input: UpdateDevicePolicyConfigurationRequest,
) -> Result<
UpdateDevicePolicyConfigurationResponse,
RusotoError<UpdateDevicePolicyConfigurationError>,
> {
let request_uri = "/updateDevicePolicyConfiguration";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateDevicePolicyConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateDevicePolicyConfigurationError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn update_domain_metadata(
&self,
input: UpdateDomainMetadataRequest,
) -> Result<UpdateDomainMetadataResponse, RusotoError<UpdateDomainMetadataError>> {
let request_uri = "/updateDomainMetadata";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateDomainMetadataResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateDomainMetadataError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_fleet_metadata(
&self,
input: UpdateFleetMetadataRequest,
) -> Result<UpdateFleetMetadataResponse, RusotoError<UpdateFleetMetadataError>> {
let request_uri = "/UpdateFleetMetadata";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateFleetMetadataResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateFleetMetadataError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_identity_provider_configuration(
&self,
input: UpdateIdentityProviderConfigurationRequest,
) -> Result<
UpdateIdentityProviderConfigurationResponse,
RusotoError<UpdateIdentityProviderConfigurationError>,
> {
let request_uri = "/updateIdentityProviderConfiguration";
let mut request = SignedRequest::new("POST", "worklink", &self.region, &request_uri);
request.set_content_type("application/json".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateIdentityProviderConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateIdentityProviderConfigurationError::from_response(
response,
))
}
}
}