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 AcceptResourceShareInvitationRequest {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "resourceShareInvitationArn")]
pub resource_share_invitation_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AcceptResourceShareInvitationResponse {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "resourceShareInvitation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_share_invitation: Option<ResourceShareInvitation>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AssociateResourceSharePermissionRequest {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "permissionArn")]
pub permission_arn: String,
#[serde(rename = "replace")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replace: Option<bool>,
#[serde(rename = "resourceShareArn")]
pub resource_share_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssociateResourceSharePermissionResponse {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "returnValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub return_value: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AssociateResourceShareRequest {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "principals")]
#[serde(skip_serializing_if = "Option::is_none")]
pub principals: Option<Vec<String>>,
#[serde(rename = "resourceArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arns: Option<Vec<String>>,
#[serde(rename = "resourceShareArn")]
pub resource_share_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssociateResourceShareResponse {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "resourceShareAssociations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_share_associations: Option<Vec<ResourceShareAssociation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateResourceShareRequest {
#[serde(rename = "allowExternalPrincipals")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_external_principals: Option<bool>,
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "permissionArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub permission_arns: Option<Vec<String>>,
#[serde(rename = "principals")]
#[serde(skip_serializing_if = "Option::is_none")]
pub principals: Option<Vec<String>>,
#[serde(rename = "resourceArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arns: Option<Vec<String>>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateResourceShareResponse {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "resourceShare")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_share: Option<ResourceShare>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteResourceShareRequest {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "resourceShareArn")]
pub resource_share_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteResourceShareResponse {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "returnValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub return_value: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisassociateResourceSharePermissionRequest {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "permissionArn")]
pub permission_arn: String,
#[serde(rename = "resourceShareArn")]
pub resource_share_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisassociateResourceSharePermissionResponse {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "returnValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub return_value: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisassociateResourceShareRequest {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "principals")]
#[serde(skip_serializing_if = "Option::is_none")]
pub principals: Option<Vec<String>>,
#[serde(rename = "resourceArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arns: Option<Vec<String>>,
#[serde(rename = "resourceShareArn")]
pub resource_share_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisassociateResourceShareResponse {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "resourceShareAssociations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_share_associations: Option<Vec<ResourceShareAssociation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct EnableSharingWithAwsOrganizationRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EnableSharingWithAwsOrganizationResponse {
#[serde(rename = "returnValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub return_value: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetPermissionRequest {
#[serde(rename = "permissionArn")]
pub permission_arn: String,
#[serde(rename = "permissionVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub permission_version: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetPermissionResponse {
#[serde(rename = "permission")]
#[serde(skip_serializing_if = "Option::is_none")]
pub permission: Option<ResourceSharePermissionDetail>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetResourcePoliciesRequest {
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "principal")]
#[serde(skip_serializing_if = "Option::is_none")]
pub principal: Option<String>,
#[serde(rename = "resourceArns")]
pub resource_arns: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetResourcePoliciesResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "policies")]
#[serde(skip_serializing_if = "Option::is_none")]
pub policies: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetResourceShareAssociationsRequest {
#[serde(rename = "associationStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub association_status: Option<String>,
#[serde(rename = "associationType")]
pub association_type: String,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "principal")]
#[serde(skip_serializing_if = "Option::is_none")]
pub principal: Option<String>,
#[serde(rename = "resourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: Option<String>,
#[serde(rename = "resourceShareArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_share_arns: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetResourceShareAssociationsResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "resourceShareAssociations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_share_associations: Option<Vec<ResourceShareAssociation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetResourceShareInvitationsRequest {
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "resourceShareArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_share_arns: Option<Vec<String>>,
#[serde(rename = "resourceShareInvitationArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_share_invitation_arns: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetResourceShareInvitationsResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "resourceShareInvitations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_share_invitations: Option<Vec<ResourceShareInvitation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetResourceSharesRequest {
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "resourceOwner")]
pub resource_owner: String,
#[serde(rename = "resourceShareArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_share_arns: Option<Vec<String>>,
#[serde(rename = "resourceShareStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_share_status: Option<String>,
#[serde(rename = "tagFilters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tag_filters: Option<Vec<TagFilter>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetResourceSharesResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "resourceShares")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_shares: Option<Vec<ResourceShare>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListPendingInvitationResourcesRequest {
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "resourceShareInvitationArn")]
pub resource_share_invitation_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListPendingInvitationResourcesResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "resources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resources: Option<Vec<Resource>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListPermissionsRequest {
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListPermissionsResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "permissions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub permissions: Option<Vec<ResourceSharePermissionSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListPrincipalsRequest {
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "principals")]
#[serde(skip_serializing_if = "Option::is_none")]
pub principals: Option<Vec<String>>,
#[serde(rename = "resourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: Option<String>,
#[serde(rename = "resourceOwner")]
pub resource_owner: String,
#[serde(rename = "resourceShareArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_share_arns: Option<Vec<String>>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListPrincipalsResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "principals")]
#[serde(skip_serializing_if = "Option::is_none")]
pub principals: Option<Vec<Principal>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListResourceSharePermissionsRequest {
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "resourceShareArn")]
pub resource_share_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListResourceSharePermissionsResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "permissions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub permissions: Option<Vec<ResourceSharePermissionSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListResourceTypesRequest {
#[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 ListResourceTypesResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "resourceTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_types: Option<Vec<ServiceNameAndResourceType>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListResourcesRequest {
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "principal")]
#[serde(skip_serializing_if = "Option::is_none")]
pub principal: Option<String>,
#[serde(rename = "resourceArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arns: Option<Vec<String>>,
#[serde(rename = "resourceOwner")]
pub resource_owner: String,
#[serde(rename = "resourceShareArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_share_arns: Option<Vec<String>>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListResourcesResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "resources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resources: Option<Vec<Resource>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Principal {
#[serde(rename = "creationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "external")]
#[serde(skip_serializing_if = "Option::is_none")]
pub external: Option<bool>,
#[serde(rename = "id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "lastUpdatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_time: Option<f64>,
#[serde(rename = "resourceShareArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_share_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PromoteResourceShareCreatedFromPolicyRequest {
#[serde(rename = "resourceShareArn")]
pub resource_share_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PromoteResourceShareCreatedFromPolicyResponse {
#[serde(rename = "returnValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub return_value: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RejectResourceShareInvitationRequest {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "resourceShareInvitationArn")]
pub resource_share_invitation_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RejectResourceShareInvitationResponse {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "resourceShareInvitation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_share_invitation: Option<ResourceShareInvitation>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Resource {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "creationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "lastUpdatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_time: Option<f64>,
#[serde(rename = "resourceGroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_group_arn: Option<String>,
#[serde(rename = "resourceShareArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_share_arn: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "statusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_message: Option<String>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResourceShare {
#[serde(rename = "allowExternalPrincipals")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_external_principals: Option<bool>,
#[serde(rename = "creationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "featureSet")]
#[serde(skip_serializing_if = "Option::is_none")]
pub feature_set: Option<String>,
#[serde(rename = "lastUpdatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_time: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "owningAccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owning_account_id: Option<String>,
#[serde(rename = "resourceShareArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_share_arn: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "statusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_message: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResourceShareAssociation {
#[serde(rename = "associatedEntity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub associated_entity: Option<String>,
#[serde(rename = "associationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub association_type: Option<String>,
#[serde(rename = "creationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "external")]
#[serde(skip_serializing_if = "Option::is_none")]
pub external: Option<bool>,
#[serde(rename = "lastUpdatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_time: Option<f64>,
#[serde(rename = "resourceShareArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_share_arn: Option<String>,
#[serde(rename = "resourceShareName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_share_name: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "statusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_message: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResourceShareInvitation {
#[serde(rename = "invitationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub invitation_timestamp: Option<f64>,
#[serde(rename = "receiverAccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub receiver_account_id: Option<String>,
#[serde(rename = "resourceShareArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_share_arn: Option<String>,
#[serde(rename = "resourceShareInvitationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_share_invitation_arn: Option<String>,
#[serde(rename = "resourceShareName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_share_name: Option<String>,
#[serde(rename = "senderAccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sender_account_id: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResourceSharePermissionDetail {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "creationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "defaultVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_version: Option<bool>,
#[serde(rename = "lastUpdatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_time: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "permission")]
#[serde(skip_serializing_if = "Option::is_none")]
pub permission: Option<String>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResourceSharePermissionSummary {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "creationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "defaultVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_version: Option<bool>,
#[serde(rename = "lastUpdatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_time: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ServiceNameAndResourceType {
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "serviceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Tag {
#[serde(rename = "key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key: Option<String>,
#[serde(rename = "value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagFilter {
#[serde(rename = "tagKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tag_key: Option<String>,
#[serde(rename = "tagValues")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tag_values: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "resourceShareArn")]
pub resource_share_arn: String,
#[serde(rename = "tags")]
pub tags: Vec<Tag>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TagResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
#[serde(rename = "resourceShareArn")]
pub resource_share_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 UpdateResourceShareRequest {
#[serde(rename = "allowExternalPrincipals")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_external_principals: Option<bool>,
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "resourceShareArn")]
pub resource_share_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateResourceShareResponse {
#[serde(rename = "clientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "resourceShare")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_share: Option<ResourceShare>,
}
#[derive(Debug, PartialEq)]
pub enum AcceptResourceShareInvitationError {
IdempotentParameterMismatch(String),
InvalidClientToken(String),
MalformedArn(String),
OperationNotPermitted(String),
ResourceShareInvitationAlreadyAccepted(String),
ResourceShareInvitationAlreadyRejected(String),
ResourceShareInvitationArnNotFound(String),
ResourceShareInvitationExpired(String),
ServerInternal(String),
ServiceUnavailable(String),
}
impl AcceptResourceShareInvitationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AcceptResourceShareInvitationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"IdempotentParameterMismatchException" => {
return RusotoError::Service(
AcceptResourceShareInvitationError::IdempotentParameterMismatch(err.msg),
)
}
"InvalidClientTokenException" => {
return RusotoError::Service(
AcceptResourceShareInvitationError::InvalidClientToken(err.msg),
)
}
"MalformedArnException" => {
return RusotoError::Service(AcceptResourceShareInvitationError::MalformedArn(
err.msg,
))
}
"OperationNotPermittedException" => {
return RusotoError::Service(
AcceptResourceShareInvitationError::OperationNotPermitted(err.msg),
)
}
"ResourceShareInvitationAlreadyAcceptedException" => {
return RusotoError::Service(
AcceptResourceShareInvitationError::ResourceShareInvitationAlreadyAccepted(
err.msg,
),
)
}
"ResourceShareInvitationAlreadyRejectedException" => {
return RusotoError::Service(
AcceptResourceShareInvitationError::ResourceShareInvitationAlreadyRejected(
err.msg,
),
)
}
"ResourceShareInvitationArnNotFoundException" => {
return RusotoError::Service(
AcceptResourceShareInvitationError::ResourceShareInvitationArnNotFound(
err.msg,
),
)
}
"ResourceShareInvitationExpiredException" => {
return RusotoError::Service(
AcceptResourceShareInvitationError::ResourceShareInvitationExpired(err.msg),
)
}
"ServerInternalException" => {
return RusotoError::Service(
AcceptResourceShareInvitationError::ServerInternal(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(
AcceptResourceShareInvitationError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AcceptResourceShareInvitationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AcceptResourceShareInvitationError::IdempotentParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
AcceptResourceShareInvitationError::InvalidClientToken(ref cause) => {
write!(f, "{}", cause)
}
AcceptResourceShareInvitationError::MalformedArn(ref cause) => write!(f, "{}", cause),
AcceptResourceShareInvitationError::OperationNotPermitted(ref cause) => {
write!(f, "{}", cause)
}
AcceptResourceShareInvitationError::ResourceShareInvitationAlreadyAccepted(
ref cause,
) => write!(f, "{}", cause),
AcceptResourceShareInvitationError::ResourceShareInvitationAlreadyRejected(
ref cause,
) => write!(f, "{}", cause),
AcceptResourceShareInvitationError::ResourceShareInvitationArnNotFound(ref cause) => {
write!(f, "{}", cause)
}
AcceptResourceShareInvitationError::ResourceShareInvitationExpired(ref cause) => {
write!(f, "{}", cause)
}
AcceptResourceShareInvitationError::ServerInternal(ref cause) => write!(f, "{}", cause),
AcceptResourceShareInvitationError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AcceptResourceShareInvitationError {}
#[derive(Debug, PartialEq)]
pub enum AssociateResourceShareError {
IdempotentParameterMismatch(String),
InvalidClientToken(String),
InvalidParameter(String),
InvalidStateTransition(String),
MalformedArn(String),
OperationNotPermitted(String),
ResourceShareLimitExceeded(String),
ServerInternal(String),
ServiceUnavailable(String),
UnknownResource(String),
}
impl AssociateResourceShareError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AssociateResourceShareError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"IdempotentParameterMismatchException" => {
return RusotoError::Service(
AssociateResourceShareError::IdempotentParameterMismatch(err.msg),
)
}
"InvalidClientTokenException" => {
return RusotoError::Service(AssociateResourceShareError::InvalidClientToken(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(AssociateResourceShareError::InvalidParameter(
err.msg,
))
}
"InvalidStateTransitionException" => {
return RusotoError::Service(
AssociateResourceShareError::InvalidStateTransition(err.msg),
)
}
"MalformedArnException" => {
return RusotoError::Service(AssociateResourceShareError::MalformedArn(err.msg))
}
"OperationNotPermittedException" => {
return RusotoError::Service(
AssociateResourceShareError::OperationNotPermitted(err.msg),
)
}
"ResourceShareLimitExceededException" => {
return RusotoError::Service(
AssociateResourceShareError::ResourceShareLimitExceeded(err.msg),
)
}
"ServerInternalException" => {
return RusotoError::Service(AssociateResourceShareError::ServerInternal(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(AssociateResourceShareError::ServiceUnavailable(
err.msg,
))
}
"UnknownResourceException" => {
return RusotoError::Service(AssociateResourceShareError::UnknownResource(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociateResourceShareError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociateResourceShareError::IdempotentParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
AssociateResourceShareError::InvalidClientToken(ref cause) => write!(f, "{}", cause),
AssociateResourceShareError::InvalidParameter(ref cause) => write!(f, "{}", cause),
AssociateResourceShareError::InvalidStateTransition(ref cause) => {
write!(f, "{}", cause)
}
AssociateResourceShareError::MalformedArn(ref cause) => write!(f, "{}", cause),
AssociateResourceShareError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
AssociateResourceShareError::ResourceShareLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
AssociateResourceShareError::ServerInternal(ref cause) => write!(f, "{}", cause),
AssociateResourceShareError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
AssociateResourceShareError::UnknownResource(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AssociateResourceShareError {}
#[derive(Debug, PartialEq)]
pub enum AssociateResourceSharePermissionError {
InvalidClientToken(String),
InvalidParameter(String),
MalformedArn(String),
OperationNotPermitted(String),
ServerInternal(String),
ServiceUnavailable(String),
UnknownResource(String),
}
impl AssociateResourceSharePermissionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AssociateResourceSharePermissionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidClientTokenException" => {
return RusotoError::Service(
AssociateResourceSharePermissionError::InvalidClientToken(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(
AssociateResourceSharePermissionError::InvalidParameter(err.msg),
)
}
"MalformedArnException" => {
return RusotoError::Service(
AssociateResourceSharePermissionError::MalformedArn(err.msg),
)
}
"OperationNotPermittedException" => {
return RusotoError::Service(
AssociateResourceSharePermissionError::OperationNotPermitted(err.msg),
)
}
"ServerInternalException" => {
return RusotoError::Service(
AssociateResourceSharePermissionError::ServerInternal(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(
AssociateResourceSharePermissionError::ServiceUnavailable(err.msg),
)
}
"UnknownResourceException" => {
return RusotoError::Service(
AssociateResourceSharePermissionError::UnknownResource(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociateResourceSharePermissionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociateResourceSharePermissionError::InvalidClientToken(ref cause) => {
write!(f, "{}", cause)
}
AssociateResourceSharePermissionError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
AssociateResourceSharePermissionError::MalformedArn(ref cause) => {
write!(f, "{}", cause)
}
AssociateResourceSharePermissionError::OperationNotPermitted(ref cause) => {
write!(f, "{}", cause)
}
AssociateResourceSharePermissionError::ServerInternal(ref cause) => {
write!(f, "{}", cause)
}
AssociateResourceSharePermissionError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
AssociateResourceSharePermissionError::UnknownResource(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AssociateResourceSharePermissionError {}
#[derive(Debug, PartialEq)]
pub enum CreateResourceShareError {
IdempotentParameterMismatch(String),
InvalidClientToken(String),
InvalidParameter(String),
InvalidStateTransition(String),
MalformedArn(String),
OperationNotPermitted(String),
ResourceShareLimitExceeded(String),
ServerInternal(String),
ServiceUnavailable(String),
TagPolicyViolation(String),
UnknownResource(String),
}
impl CreateResourceShareError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateResourceShareError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"IdempotentParameterMismatchException" => {
return RusotoError::Service(
CreateResourceShareError::IdempotentParameterMismatch(err.msg),
)
}
"InvalidClientTokenException" => {
return RusotoError::Service(CreateResourceShareError::InvalidClientToken(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateResourceShareError::InvalidParameter(
err.msg,
))
}
"InvalidStateTransitionException" => {
return RusotoError::Service(CreateResourceShareError::InvalidStateTransition(
err.msg,
))
}
"MalformedArnException" => {
return RusotoError::Service(CreateResourceShareError::MalformedArn(err.msg))
}
"OperationNotPermittedException" => {
return RusotoError::Service(CreateResourceShareError::OperationNotPermitted(
err.msg,
))
}
"ResourceShareLimitExceededException" => {
return RusotoError::Service(
CreateResourceShareError::ResourceShareLimitExceeded(err.msg),
)
}
"ServerInternalException" => {
return RusotoError::Service(CreateResourceShareError::ServerInternal(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(CreateResourceShareError::ServiceUnavailable(
err.msg,
))
}
"TagPolicyViolationException" => {
return RusotoError::Service(CreateResourceShareError::TagPolicyViolation(
err.msg,
))
}
"UnknownResourceException" => {
return RusotoError::Service(CreateResourceShareError::UnknownResource(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateResourceShareError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateResourceShareError::IdempotentParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
CreateResourceShareError::InvalidClientToken(ref cause) => write!(f, "{}", cause),
CreateResourceShareError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateResourceShareError::InvalidStateTransition(ref cause) => write!(f, "{}", cause),
CreateResourceShareError::MalformedArn(ref cause) => write!(f, "{}", cause),
CreateResourceShareError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
CreateResourceShareError::ResourceShareLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
CreateResourceShareError::ServerInternal(ref cause) => write!(f, "{}", cause),
CreateResourceShareError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
CreateResourceShareError::TagPolicyViolation(ref cause) => write!(f, "{}", cause),
CreateResourceShareError::UnknownResource(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateResourceShareError {}
#[derive(Debug, PartialEq)]
pub enum DeleteResourceShareError {
IdempotentParameterMismatch(String),
InvalidClientToken(String),
InvalidParameter(String),
InvalidStateTransition(String),
MalformedArn(String),
OperationNotPermitted(String),
ServerInternal(String),
ServiceUnavailable(String),
UnknownResource(String),
}
impl DeleteResourceShareError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteResourceShareError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"IdempotentParameterMismatchException" => {
return RusotoError::Service(
DeleteResourceShareError::IdempotentParameterMismatch(err.msg),
)
}
"InvalidClientTokenException" => {
return RusotoError::Service(DeleteResourceShareError::InvalidClientToken(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DeleteResourceShareError::InvalidParameter(
err.msg,
))
}
"InvalidStateTransitionException" => {
return RusotoError::Service(DeleteResourceShareError::InvalidStateTransition(
err.msg,
))
}
"MalformedArnException" => {
return RusotoError::Service(DeleteResourceShareError::MalformedArn(err.msg))
}
"OperationNotPermittedException" => {
return RusotoError::Service(DeleteResourceShareError::OperationNotPermitted(
err.msg,
))
}
"ServerInternalException" => {
return RusotoError::Service(DeleteResourceShareError::ServerInternal(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DeleteResourceShareError::ServiceUnavailable(
err.msg,
))
}
"UnknownResourceException" => {
return RusotoError::Service(DeleteResourceShareError::UnknownResource(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteResourceShareError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteResourceShareError::IdempotentParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
DeleteResourceShareError::InvalidClientToken(ref cause) => write!(f, "{}", cause),
DeleteResourceShareError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteResourceShareError::InvalidStateTransition(ref cause) => write!(f, "{}", cause),
DeleteResourceShareError::MalformedArn(ref cause) => write!(f, "{}", cause),
DeleteResourceShareError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
DeleteResourceShareError::ServerInternal(ref cause) => write!(f, "{}", cause),
DeleteResourceShareError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
DeleteResourceShareError::UnknownResource(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteResourceShareError {}
#[derive(Debug, PartialEq)]
pub enum DisassociateResourceShareError {
IdempotentParameterMismatch(String),
InvalidClientToken(String),
InvalidParameter(String),
InvalidStateTransition(String),
MalformedArn(String),
OperationNotPermitted(String),
ResourceShareLimitExceeded(String),
ServerInternal(String),
ServiceUnavailable(String),
UnknownResource(String),
}
impl DisassociateResourceShareError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DisassociateResourceShareError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"IdempotentParameterMismatchException" => {
return RusotoError::Service(
DisassociateResourceShareError::IdempotentParameterMismatch(err.msg),
)
}
"InvalidClientTokenException" => {
return RusotoError::Service(
DisassociateResourceShareError::InvalidClientToken(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(DisassociateResourceShareError::InvalidParameter(
err.msg,
))
}
"InvalidStateTransitionException" => {
return RusotoError::Service(
DisassociateResourceShareError::InvalidStateTransition(err.msg),
)
}
"MalformedArnException" => {
return RusotoError::Service(DisassociateResourceShareError::MalformedArn(
err.msg,
))
}
"OperationNotPermittedException" => {
return RusotoError::Service(
DisassociateResourceShareError::OperationNotPermitted(err.msg),
)
}
"ResourceShareLimitExceededException" => {
return RusotoError::Service(
DisassociateResourceShareError::ResourceShareLimitExceeded(err.msg),
)
}
"ServerInternalException" => {
return RusotoError::Service(DisassociateResourceShareError::ServerInternal(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(
DisassociateResourceShareError::ServiceUnavailable(err.msg),
)
}
"UnknownResourceException" => {
return RusotoError::Service(DisassociateResourceShareError::UnknownResource(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisassociateResourceShareError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisassociateResourceShareError::IdempotentParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
DisassociateResourceShareError::InvalidClientToken(ref cause) => write!(f, "{}", cause),
DisassociateResourceShareError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DisassociateResourceShareError::InvalidStateTransition(ref cause) => {
write!(f, "{}", cause)
}
DisassociateResourceShareError::MalformedArn(ref cause) => write!(f, "{}", cause),
DisassociateResourceShareError::OperationNotPermitted(ref cause) => {
write!(f, "{}", cause)
}
DisassociateResourceShareError::ResourceShareLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
DisassociateResourceShareError::ServerInternal(ref cause) => write!(f, "{}", cause),
DisassociateResourceShareError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
DisassociateResourceShareError::UnknownResource(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DisassociateResourceShareError {}
#[derive(Debug, PartialEq)]
pub enum DisassociateResourceSharePermissionError {
InvalidClientToken(String),
InvalidParameter(String),
MalformedArn(String),
OperationNotPermitted(String),
ServerInternal(String),
ServiceUnavailable(String),
UnknownResource(String),
}
impl DisassociateResourceSharePermissionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisassociateResourceSharePermissionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidClientTokenException" => {
return RusotoError::Service(
DisassociateResourceSharePermissionError::InvalidClientToken(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(
DisassociateResourceSharePermissionError::InvalidParameter(err.msg),
)
}
"MalformedArnException" => {
return RusotoError::Service(
DisassociateResourceSharePermissionError::MalformedArn(err.msg),
)
}
"OperationNotPermittedException" => {
return RusotoError::Service(
DisassociateResourceSharePermissionError::OperationNotPermitted(err.msg),
)
}
"ServerInternalException" => {
return RusotoError::Service(
DisassociateResourceSharePermissionError::ServerInternal(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(
DisassociateResourceSharePermissionError::ServiceUnavailable(err.msg),
)
}
"UnknownResourceException" => {
return RusotoError::Service(
DisassociateResourceSharePermissionError::UnknownResource(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisassociateResourceSharePermissionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisassociateResourceSharePermissionError::InvalidClientToken(ref cause) => {
write!(f, "{}", cause)
}
DisassociateResourceSharePermissionError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
DisassociateResourceSharePermissionError::MalformedArn(ref cause) => {
write!(f, "{}", cause)
}
DisassociateResourceSharePermissionError::OperationNotPermitted(ref cause) => {
write!(f, "{}", cause)
}
DisassociateResourceSharePermissionError::ServerInternal(ref cause) => {
write!(f, "{}", cause)
}
DisassociateResourceSharePermissionError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
DisassociateResourceSharePermissionError::UnknownResource(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DisassociateResourceSharePermissionError {}
#[derive(Debug, PartialEq)]
pub enum EnableSharingWithAwsOrganizationError {
OperationNotPermitted(String),
ServerInternal(String),
ServiceUnavailable(String),
}
impl EnableSharingWithAwsOrganizationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<EnableSharingWithAwsOrganizationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"OperationNotPermittedException" => {
return RusotoError::Service(
EnableSharingWithAwsOrganizationError::OperationNotPermitted(err.msg),
)
}
"ServerInternalException" => {
return RusotoError::Service(
EnableSharingWithAwsOrganizationError::ServerInternal(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(
EnableSharingWithAwsOrganizationError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for EnableSharingWithAwsOrganizationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
EnableSharingWithAwsOrganizationError::OperationNotPermitted(ref cause) => {
write!(f, "{}", cause)
}
EnableSharingWithAwsOrganizationError::ServerInternal(ref cause) => {
write!(f, "{}", cause)
}
EnableSharingWithAwsOrganizationError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for EnableSharingWithAwsOrganizationError {}
#[derive(Debug, PartialEq)]
pub enum GetPermissionError {
InvalidParameter(String),
MalformedArn(String),
OperationNotPermitted(String),
ServerInternal(String),
ServiceUnavailable(String),
UnknownResource(String),
}
impl GetPermissionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetPermissionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterException" => {
return RusotoError::Service(GetPermissionError::InvalidParameter(err.msg))
}
"MalformedArnException" => {
return RusotoError::Service(GetPermissionError::MalformedArn(err.msg))
}
"OperationNotPermittedException" => {
return RusotoError::Service(GetPermissionError::OperationNotPermitted(err.msg))
}
"ServerInternalException" => {
return RusotoError::Service(GetPermissionError::ServerInternal(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(GetPermissionError::ServiceUnavailable(err.msg))
}
"UnknownResourceException" => {
return RusotoError::Service(GetPermissionError::UnknownResource(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetPermissionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetPermissionError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetPermissionError::MalformedArn(ref cause) => write!(f, "{}", cause),
GetPermissionError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
GetPermissionError::ServerInternal(ref cause) => write!(f, "{}", cause),
GetPermissionError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
GetPermissionError::UnknownResource(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetPermissionError {}
#[derive(Debug, PartialEq)]
pub enum GetResourcePoliciesError {
InvalidNextToken(String),
InvalidParameter(String),
MalformedArn(String),
ResourceArnNotFound(String),
ServerInternal(String),
ServiceUnavailable(String),
}
impl GetResourcePoliciesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetResourcePoliciesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(GetResourcePoliciesError::InvalidNextToken(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(GetResourcePoliciesError::InvalidParameter(
err.msg,
))
}
"MalformedArnException" => {
return RusotoError::Service(GetResourcePoliciesError::MalformedArn(err.msg))
}
"ResourceArnNotFoundException" => {
return RusotoError::Service(GetResourcePoliciesError::ResourceArnNotFound(
err.msg,
))
}
"ServerInternalException" => {
return RusotoError::Service(GetResourcePoliciesError::ServerInternal(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(GetResourcePoliciesError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetResourcePoliciesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetResourcePoliciesError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
GetResourcePoliciesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetResourcePoliciesError::MalformedArn(ref cause) => write!(f, "{}", cause),
GetResourcePoliciesError::ResourceArnNotFound(ref cause) => write!(f, "{}", cause),
GetResourcePoliciesError::ServerInternal(ref cause) => write!(f, "{}", cause),
GetResourcePoliciesError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetResourcePoliciesError {}
#[derive(Debug, PartialEq)]
pub enum GetResourceShareAssociationsError {
InvalidNextToken(String),
InvalidParameter(String),
MalformedArn(String),
OperationNotPermitted(String),
ServerInternal(String),
ServiceUnavailable(String),
UnknownResource(String),
}
impl GetResourceShareAssociationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetResourceShareAssociationsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(
GetResourceShareAssociationsError::InvalidNextToken(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(
GetResourceShareAssociationsError::InvalidParameter(err.msg),
)
}
"MalformedArnException" => {
return RusotoError::Service(GetResourceShareAssociationsError::MalformedArn(
err.msg,
))
}
"OperationNotPermittedException" => {
return RusotoError::Service(
GetResourceShareAssociationsError::OperationNotPermitted(err.msg),
)
}
"ServerInternalException" => {
return RusotoError::Service(GetResourceShareAssociationsError::ServerInternal(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(
GetResourceShareAssociationsError::ServiceUnavailable(err.msg),
)
}
"UnknownResourceException" => {
return RusotoError::Service(
GetResourceShareAssociationsError::UnknownResource(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetResourceShareAssociationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetResourceShareAssociationsError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
GetResourceShareAssociationsError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
GetResourceShareAssociationsError::MalformedArn(ref cause) => write!(f, "{}", cause),
GetResourceShareAssociationsError::OperationNotPermitted(ref cause) => {
write!(f, "{}", cause)
}
GetResourceShareAssociationsError::ServerInternal(ref cause) => write!(f, "{}", cause),
GetResourceShareAssociationsError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
GetResourceShareAssociationsError::UnknownResource(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetResourceShareAssociationsError {}
#[derive(Debug, PartialEq)]
pub enum GetResourceShareInvitationsError {
InvalidMaxResults(String),
InvalidNextToken(String),
InvalidParameter(String),
MalformedArn(String),
ResourceShareInvitationArnNotFound(String),
ServerInternal(String),
ServiceUnavailable(String),
UnknownResource(String),
}
impl GetResourceShareInvitationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetResourceShareInvitationsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidMaxResultsException" => {
return RusotoError::Service(
GetResourceShareInvitationsError::InvalidMaxResults(err.msg),
)
}
"InvalidNextTokenException" => {
return RusotoError::Service(
GetResourceShareInvitationsError::InvalidNextToken(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(
GetResourceShareInvitationsError::InvalidParameter(err.msg),
)
}
"MalformedArnException" => {
return RusotoError::Service(GetResourceShareInvitationsError::MalformedArn(
err.msg,
))
}
"ResourceShareInvitationArnNotFoundException" => {
return RusotoError::Service(
GetResourceShareInvitationsError::ResourceShareInvitationArnNotFound(
err.msg,
),
)
}
"ServerInternalException" => {
return RusotoError::Service(GetResourceShareInvitationsError::ServerInternal(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(
GetResourceShareInvitationsError::ServiceUnavailable(err.msg),
)
}
"UnknownResourceException" => {
return RusotoError::Service(GetResourceShareInvitationsError::UnknownResource(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetResourceShareInvitationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetResourceShareInvitationsError::InvalidMaxResults(ref cause) => {
write!(f, "{}", cause)
}
GetResourceShareInvitationsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
GetResourceShareInvitationsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetResourceShareInvitationsError::MalformedArn(ref cause) => write!(f, "{}", cause),
GetResourceShareInvitationsError::ResourceShareInvitationArnNotFound(ref cause) => {
write!(f, "{}", cause)
}
GetResourceShareInvitationsError::ServerInternal(ref cause) => write!(f, "{}", cause),
GetResourceShareInvitationsError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
GetResourceShareInvitationsError::UnknownResource(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetResourceShareInvitationsError {}
#[derive(Debug, PartialEq)]
pub enum GetResourceSharesError {
InvalidNextToken(String),
InvalidParameter(String),
MalformedArn(String),
ServerInternal(String),
ServiceUnavailable(String),
UnknownResource(String),
}
impl GetResourceSharesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetResourceSharesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(GetResourceSharesError::InvalidNextToken(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(GetResourceSharesError::InvalidParameter(err.msg))
}
"MalformedArnException" => {
return RusotoError::Service(GetResourceSharesError::MalformedArn(err.msg))
}
"ServerInternalException" => {
return RusotoError::Service(GetResourceSharesError::ServerInternal(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(GetResourceSharesError::ServiceUnavailable(
err.msg,
))
}
"UnknownResourceException" => {
return RusotoError::Service(GetResourceSharesError::UnknownResource(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetResourceSharesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetResourceSharesError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
GetResourceSharesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetResourceSharesError::MalformedArn(ref cause) => write!(f, "{}", cause),
GetResourceSharesError::ServerInternal(ref cause) => write!(f, "{}", cause),
GetResourceSharesError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
GetResourceSharesError::UnknownResource(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetResourceSharesError {}
#[derive(Debug, PartialEq)]
pub enum ListPendingInvitationResourcesError {
InvalidNextToken(String),
InvalidParameter(String),
MalformedArn(String),
MissingRequiredParameter(String),
ResourceShareInvitationAlreadyRejected(String),
ResourceShareInvitationArnNotFound(String),
ResourceShareInvitationExpired(String),
ServerInternal(String),
ServiceUnavailable(String),
}
impl ListPendingInvitationResourcesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListPendingInvitationResourcesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(
ListPendingInvitationResourcesError::InvalidNextToken(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(
ListPendingInvitationResourcesError::InvalidParameter(err.msg),
)
}
"MalformedArnException" => {
return RusotoError::Service(ListPendingInvitationResourcesError::MalformedArn(
err.msg,
))
}
"MissingRequiredParameterException" => {
return RusotoError::Service(
ListPendingInvitationResourcesError::MissingRequiredParameter(err.msg),
)
}
"ResourceShareInvitationAlreadyRejectedException" => {
return RusotoError::Service(
ListPendingInvitationResourcesError::ResourceShareInvitationAlreadyRejected(
err.msg,
),
)
}
"ResourceShareInvitationArnNotFoundException" => {
return RusotoError::Service(
ListPendingInvitationResourcesError::ResourceShareInvitationArnNotFound(
err.msg,
),
)
}
"ResourceShareInvitationExpiredException" => {
return RusotoError::Service(
ListPendingInvitationResourcesError::ResourceShareInvitationExpired(
err.msg,
),
)
}
"ServerInternalException" => {
return RusotoError::Service(
ListPendingInvitationResourcesError::ServerInternal(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(
ListPendingInvitationResourcesError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListPendingInvitationResourcesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListPendingInvitationResourcesError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
ListPendingInvitationResourcesError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
ListPendingInvitationResourcesError::MalformedArn(ref cause) => write!(f, "{}", cause),
ListPendingInvitationResourcesError::MissingRequiredParameter(ref cause) => {
write!(f, "{}", cause)
}
ListPendingInvitationResourcesError::ResourceShareInvitationAlreadyRejected(
ref cause,
) => write!(f, "{}", cause),
ListPendingInvitationResourcesError::ResourceShareInvitationArnNotFound(ref cause) => {
write!(f, "{}", cause)
}
ListPendingInvitationResourcesError::ResourceShareInvitationExpired(ref cause) => {
write!(f, "{}", cause)
}
ListPendingInvitationResourcesError::ServerInternal(ref cause) => {
write!(f, "{}", cause)
}
ListPendingInvitationResourcesError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListPendingInvitationResourcesError {}
#[derive(Debug, PartialEq)]
pub enum ListPermissionsError {
InvalidNextToken(String),
InvalidParameter(String),
OperationNotPermitted(String),
ServerInternal(String),
ServiceUnavailable(String),
}
impl ListPermissionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListPermissionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(ListPermissionsError::InvalidNextToken(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListPermissionsError::InvalidParameter(err.msg))
}
"OperationNotPermittedException" => {
return RusotoError::Service(ListPermissionsError::OperationNotPermitted(
err.msg,
))
}
"ServerInternalException" => {
return RusotoError::Service(ListPermissionsError::ServerInternal(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListPermissionsError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListPermissionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListPermissionsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListPermissionsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListPermissionsError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
ListPermissionsError::ServerInternal(ref cause) => write!(f, "{}", cause),
ListPermissionsError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListPermissionsError {}
#[derive(Debug, PartialEq)]
pub enum ListPrincipalsError {
InvalidNextToken(String),
InvalidParameter(String),
MalformedArn(String),
ServerInternal(String),
ServiceUnavailable(String),
UnknownResource(String),
}
impl ListPrincipalsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListPrincipalsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(ListPrincipalsError::InvalidNextToken(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListPrincipalsError::InvalidParameter(err.msg))
}
"MalformedArnException" => {
return RusotoError::Service(ListPrincipalsError::MalformedArn(err.msg))
}
"ServerInternalException" => {
return RusotoError::Service(ListPrincipalsError::ServerInternal(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListPrincipalsError::ServiceUnavailable(err.msg))
}
"UnknownResourceException" => {
return RusotoError::Service(ListPrincipalsError::UnknownResource(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListPrincipalsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListPrincipalsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListPrincipalsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListPrincipalsError::MalformedArn(ref cause) => write!(f, "{}", cause),
ListPrincipalsError::ServerInternal(ref cause) => write!(f, "{}", cause),
ListPrincipalsError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
ListPrincipalsError::UnknownResource(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListPrincipalsError {}
#[derive(Debug, PartialEq)]
pub enum ListResourceSharePermissionsError {
InvalidNextToken(String),
InvalidParameter(String),
MalformedArn(String),
OperationNotPermitted(String),
ServerInternal(String),
ServiceUnavailable(String),
UnknownResource(String),
}
impl ListResourceSharePermissionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListResourceSharePermissionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(
ListResourceSharePermissionsError::InvalidNextToken(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(
ListResourceSharePermissionsError::InvalidParameter(err.msg),
)
}
"MalformedArnException" => {
return RusotoError::Service(ListResourceSharePermissionsError::MalformedArn(
err.msg,
))
}
"OperationNotPermittedException" => {
return RusotoError::Service(
ListResourceSharePermissionsError::OperationNotPermitted(err.msg),
)
}
"ServerInternalException" => {
return RusotoError::Service(ListResourceSharePermissionsError::ServerInternal(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(
ListResourceSharePermissionsError::ServiceUnavailable(err.msg),
)
}
"UnknownResourceException" => {
return RusotoError::Service(
ListResourceSharePermissionsError::UnknownResource(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListResourceSharePermissionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListResourceSharePermissionsError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
ListResourceSharePermissionsError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
ListResourceSharePermissionsError::MalformedArn(ref cause) => write!(f, "{}", cause),
ListResourceSharePermissionsError::OperationNotPermitted(ref cause) => {
write!(f, "{}", cause)
}
ListResourceSharePermissionsError::ServerInternal(ref cause) => write!(f, "{}", cause),
ListResourceSharePermissionsError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
ListResourceSharePermissionsError::UnknownResource(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListResourceSharePermissionsError {}
#[derive(Debug, PartialEq)]
pub enum ListResourceTypesError {
InvalidNextToken(String),
InvalidParameter(String),
ServerInternal(String),
ServiceUnavailable(String),
}
impl ListResourceTypesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListResourceTypesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(ListResourceTypesError::InvalidNextToken(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListResourceTypesError::InvalidParameter(err.msg))
}
"ServerInternalException" => {
return RusotoError::Service(ListResourceTypesError::ServerInternal(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListResourceTypesError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListResourceTypesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListResourceTypesError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListResourceTypesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListResourceTypesError::ServerInternal(ref cause) => write!(f, "{}", cause),
ListResourceTypesError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListResourceTypesError {}
#[derive(Debug, PartialEq)]
pub enum ListResourcesError {
InvalidNextToken(String),
InvalidParameter(String),
InvalidResourceType(String),
MalformedArn(String),
ServerInternal(String),
ServiceUnavailable(String),
UnknownResource(String),
}
impl ListResourcesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListResourcesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(ListResourcesError::InvalidNextToken(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListResourcesError::InvalidParameter(err.msg))
}
"InvalidResourceTypeException" => {
return RusotoError::Service(ListResourcesError::InvalidResourceType(err.msg))
}
"MalformedArnException" => {
return RusotoError::Service(ListResourcesError::MalformedArn(err.msg))
}
"ServerInternalException" => {
return RusotoError::Service(ListResourcesError::ServerInternal(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListResourcesError::ServiceUnavailable(err.msg))
}
"UnknownResourceException" => {
return RusotoError::Service(ListResourcesError::UnknownResource(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListResourcesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListResourcesError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListResourcesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListResourcesError::InvalidResourceType(ref cause) => write!(f, "{}", cause),
ListResourcesError::MalformedArn(ref cause) => write!(f, "{}", cause),
ListResourcesError::ServerInternal(ref cause) => write!(f, "{}", cause),
ListResourcesError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
ListResourcesError::UnknownResource(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListResourcesError {}
#[derive(Debug, PartialEq)]
pub enum PromoteResourceShareCreatedFromPolicyError {
InvalidParameter(String),
MalformedArn(String),
MissingRequiredParameter(String),
OperationNotPermitted(String),
ServerInternal(String),
ServiceUnavailable(String),
UnknownResource(String),
}
impl PromoteResourceShareCreatedFromPolicyError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PromoteResourceShareCreatedFromPolicyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterException" => {
return RusotoError::Service(
PromoteResourceShareCreatedFromPolicyError::InvalidParameter(err.msg),
)
}
"MalformedArnException" => {
return RusotoError::Service(
PromoteResourceShareCreatedFromPolicyError::MalformedArn(err.msg),
)
}
"MissingRequiredParameterException" => {
return RusotoError::Service(
PromoteResourceShareCreatedFromPolicyError::MissingRequiredParameter(
err.msg,
),
)
}
"OperationNotPermittedException" => {
return RusotoError::Service(
PromoteResourceShareCreatedFromPolicyError::OperationNotPermitted(err.msg),
)
}
"ServerInternalException" => {
return RusotoError::Service(
PromoteResourceShareCreatedFromPolicyError::ServerInternal(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(
PromoteResourceShareCreatedFromPolicyError::ServiceUnavailable(err.msg),
)
}
"UnknownResourceException" => {
return RusotoError::Service(
PromoteResourceShareCreatedFromPolicyError::UnknownResource(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PromoteResourceShareCreatedFromPolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PromoteResourceShareCreatedFromPolicyError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
PromoteResourceShareCreatedFromPolicyError::MalformedArn(ref cause) => {
write!(f, "{}", cause)
}
PromoteResourceShareCreatedFromPolicyError::MissingRequiredParameter(ref cause) => {
write!(f, "{}", cause)
}
PromoteResourceShareCreatedFromPolicyError::OperationNotPermitted(ref cause) => {
write!(f, "{}", cause)
}
PromoteResourceShareCreatedFromPolicyError::ServerInternal(ref cause) => {
write!(f, "{}", cause)
}
PromoteResourceShareCreatedFromPolicyError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
PromoteResourceShareCreatedFromPolicyError::UnknownResource(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PromoteResourceShareCreatedFromPolicyError {}
#[derive(Debug, PartialEq)]
pub enum RejectResourceShareInvitationError {
IdempotentParameterMismatch(String),
InvalidClientToken(String),
MalformedArn(String),
OperationNotPermitted(String),
ResourceShareInvitationAlreadyAccepted(String),
ResourceShareInvitationAlreadyRejected(String),
ResourceShareInvitationArnNotFound(String),
ResourceShareInvitationExpired(String),
ServerInternal(String),
ServiceUnavailable(String),
}
impl RejectResourceShareInvitationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<RejectResourceShareInvitationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"IdempotentParameterMismatchException" => {
return RusotoError::Service(
RejectResourceShareInvitationError::IdempotentParameterMismatch(err.msg),
)
}
"InvalidClientTokenException" => {
return RusotoError::Service(
RejectResourceShareInvitationError::InvalidClientToken(err.msg),
)
}
"MalformedArnException" => {
return RusotoError::Service(RejectResourceShareInvitationError::MalformedArn(
err.msg,
))
}
"OperationNotPermittedException" => {
return RusotoError::Service(
RejectResourceShareInvitationError::OperationNotPermitted(err.msg),
)
}
"ResourceShareInvitationAlreadyAcceptedException" => {
return RusotoError::Service(
RejectResourceShareInvitationError::ResourceShareInvitationAlreadyAccepted(
err.msg,
),
)
}
"ResourceShareInvitationAlreadyRejectedException" => {
return RusotoError::Service(
RejectResourceShareInvitationError::ResourceShareInvitationAlreadyRejected(
err.msg,
),
)
}
"ResourceShareInvitationArnNotFoundException" => {
return RusotoError::Service(
RejectResourceShareInvitationError::ResourceShareInvitationArnNotFound(
err.msg,
),
)
}
"ResourceShareInvitationExpiredException" => {
return RusotoError::Service(
RejectResourceShareInvitationError::ResourceShareInvitationExpired(err.msg),
)
}
"ServerInternalException" => {
return RusotoError::Service(
RejectResourceShareInvitationError::ServerInternal(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(
RejectResourceShareInvitationError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RejectResourceShareInvitationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RejectResourceShareInvitationError::IdempotentParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
RejectResourceShareInvitationError::InvalidClientToken(ref cause) => {
write!(f, "{}", cause)
}
RejectResourceShareInvitationError::MalformedArn(ref cause) => write!(f, "{}", cause),
RejectResourceShareInvitationError::OperationNotPermitted(ref cause) => {
write!(f, "{}", cause)
}
RejectResourceShareInvitationError::ResourceShareInvitationAlreadyAccepted(
ref cause,
) => write!(f, "{}", cause),
RejectResourceShareInvitationError::ResourceShareInvitationAlreadyRejected(
ref cause,
) => write!(f, "{}", cause),
RejectResourceShareInvitationError::ResourceShareInvitationArnNotFound(ref cause) => {
write!(f, "{}", cause)
}
RejectResourceShareInvitationError::ResourceShareInvitationExpired(ref cause) => {
write!(f, "{}", cause)
}
RejectResourceShareInvitationError::ServerInternal(ref cause) => write!(f, "{}", cause),
RejectResourceShareInvitationError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for RejectResourceShareInvitationError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
InvalidParameter(String),
MalformedArn(String),
ResourceArnNotFound(String),
ServerInternal(String),
ServiceUnavailable(String),
TagLimitExceeded(String),
TagPolicyViolation(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() {
"InvalidParameterException" => {
return RusotoError::Service(TagResourceError::InvalidParameter(err.msg))
}
"MalformedArnException" => {
return RusotoError::Service(TagResourceError::MalformedArn(err.msg))
}
"ResourceArnNotFoundException" => {
return RusotoError::Service(TagResourceError::ResourceArnNotFound(err.msg))
}
"ServerInternalException" => {
return RusotoError::Service(TagResourceError::ServerInternal(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(TagResourceError::ServiceUnavailable(err.msg))
}
"TagLimitExceededException" => {
return RusotoError::Service(TagResourceError::TagLimitExceeded(err.msg))
}
"TagPolicyViolationException" => {
return RusotoError::Service(TagResourceError::TagPolicyViolation(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::InvalidParameter(ref cause) => write!(f, "{}", cause),
TagResourceError::MalformedArn(ref cause) => write!(f, "{}", cause),
TagResourceError::ResourceArnNotFound(ref cause) => write!(f, "{}", cause),
TagResourceError::ServerInternal(ref cause) => write!(f, "{}", cause),
TagResourceError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
TagResourceError::TagLimitExceeded(ref cause) => write!(f, "{}", cause),
TagResourceError::TagPolicyViolation(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
InvalidParameter(String),
ServerInternal(String),
ServiceUnavailable(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() {
"InvalidParameterException" => {
return RusotoError::Service(UntagResourceError::InvalidParameter(err.msg))
}
"ServerInternalException" => {
return RusotoError::Service(UntagResourceError::ServerInternal(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(UntagResourceError::ServiceUnavailable(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::InvalidParameter(ref cause) => write!(f, "{}", cause),
UntagResourceError::ServerInternal(ref cause) => write!(f, "{}", cause),
UntagResourceError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateResourceShareError {
IdempotentParameterMismatch(String),
InvalidClientToken(String),
InvalidParameter(String),
MalformedArn(String),
MissingRequiredParameter(String),
OperationNotPermitted(String),
ServerInternal(String),
ServiceUnavailable(String),
UnknownResource(String),
}
impl UpdateResourceShareError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateResourceShareError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"IdempotentParameterMismatchException" => {
return RusotoError::Service(
UpdateResourceShareError::IdempotentParameterMismatch(err.msg),
)
}
"InvalidClientTokenException" => {
return RusotoError::Service(UpdateResourceShareError::InvalidClientToken(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateResourceShareError::InvalidParameter(
err.msg,
))
}
"MalformedArnException" => {
return RusotoError::Service(UpdateResourceShareError::MalformedArn(err.msg))
}
"MissingRequiredParameterException" => {
return RusotoError::Service(
UpdateResourceShareError::MissingRequiredParameter(err.msg),
)
}
"OperationNotPermittedException" => {
return RusotoError::Service(UpdateResourceShareError::OperationNotPermitted(
err.msg,
))
}
"ServerInternalException" => {
return RusotoError::Service(UpdateResourceShareError::ServerInternal(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(UpdateResourceShareError::ServiceUnavailable(
err.msg,
))
}
"UnknownResourceException" => {
return RusotoError::Service(UpdateResourceShareError::UnknownResource(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateResourceShareError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateResourceShareError::IdempotentParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
UpdateResourceShareError::InvalidClientToken(ref cause) => write!(f, "{}", cause),
UpdateResourceShareError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateResourceShareError::MalformedArn(ref cause) => write!(f, "{}", cause),
UpdateResourceShareError::MissingRequiredParameter(ref cause) => write!(f, "{}", cause),
UpdateResourceShareError::OperationNotPermitted(ref cause) => write!(f, "{}", cause),
UpdateResourceShareError::ServerInternal(ref cause) => write!(f, "{}", cause),
UpdateResourceShareError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
UpdateResourceShareError::UnknownResource(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateResourceShareError {}
#[async_trait]
pub trait Ram {
async fn accept_resource_share_invitation(
&self,
input: AcceptResourceShareInvitationRequest,
) -> Result<
AcceptResourceShareInvitationResponse,
RusotoError<AcceptResourceShareInvitationError>,
>;
async fn associate_resource_share(
&self,
input: AssociateResourceShareRequest,
) -> Result<AssociateResourceShareResponse, RusotoError<AssociateResourceShareError>>;
async fn associate_resource_share_permission(
&self,
input: AssociateResourceSharePermissionRequest,
) -> Result<
AssociateResourceSharePermissionResponse,
RusotoError<AssociateResourceSharePermissionError>,
>;
async fn create_resource_share(
&self,
input: CreateResourceShareRequest,
) -> Result<CreateResourceShareResponse, RusotoError<CreateResourceShareError>>;
async fn delete_resource_share(
&self,
input: DeleteResourceShareRequest,
) -> Result<DeleteResourceShareResponse, RusotoError<DeleteResourceShareError>>;
async fn disassociate_resource_share(
&self,
input: DisassociateResourceShareRequest,
) -> Result<DisassociateResourceShareResponse, RusotoError<DisassociateResourceShareError>>;
async fn disassociate_resource_share_permission(
&self,
input: DisassociateResourceSharePermissionRequest,
) -> Result<
DisassociateResourceSharePermissionResponse,
RusotoError<DisassociateResourceSharePermissionError>,
>;
async fn enable_sharing_with_aws_organization(
&self,
) -> Result<
EnableSharingWithAwsOrganizationResponse,
RusotoError<EnableSharingWithAwsOrganizationError>,
>;
async fn get_permission(
&self,
input: GetPermissionRequest,
) -> Result<GetPermissionResponse, RusotoError<GetPermissionError>>;
async fn get_resource_policies(
&self,
input: GetResourcePoliciesRequest,
) -> Result<GetResourcePoliciesResponse, RusotoError<GetResourcePoliciesError>>;
async fn get_resource_share_associations(
&self,
input: GetResourceShareAssociationsRequest,
) -> Result<GetResourceShareAssociationsResponse, RusotoError<GetResourceShareAssociationsError>>;
async fn get_resource_share_invitations(
&self,
input: GetResourceShareInvitationsRequest,
) -> Result<GetResourceShareInvitationsResponse, RusotoError<GetResourceShareInvitationsError>>;
async fn get_resource_shares(
&self,
input: GetResourceSharesRequest,
) -> Result<GetResourceSharesResponse, RusotoError<GetResourceSharesError>>;
async fn list_pending_invitation_resources(
&self,
input: ListPendingInvitationResourcesRequest,
) -> Result<
ListPendingInvitationResourcesResponse,
RusotoError<ListPendingInvitationResourcesError>,
>;
async fn list_permissions(
&self,
input: ListPermissionsRequest,
) -> Result<ListPermissionsResponse, RusotoError<ListPermissionsError>>;
async fn list_principals(
&self,
input: ListPrincipalsRequest,
) -> Result<ListPrincipalsResponse, RusotoError<ListPrincipalsError>>;
async fn list_resource_share_permissions(
&self,
input: ListResourceSharePermissionsRequest,
) -> Result<ListResourceSharePermissionsResponse, RusotoError<ListResourceSharePermissionsError>>;
async fn list_resource_types(
&self,
input: ListResourceTypesRequest,
) -> Result<ListResourceTypesResponse, RusotoError<ListResourceTypesError>>;
async fn list_resources(
&self,
input: ListResourcesRequest,
) -> Result<ListResourcesResponse, RusotoError<ListResourcesError>>;
async fn promote_resource_share_created_from_policy(
&self,
input: PromoteResourceShareCreatedFromPolicyRequest,
) -> Result<
PromoteResourceShareCreatedFromPolicyResponse,
RusotoError<PromoteResourceShareCreatedFromPolicyError>,
>;
async fn reject_resource_share_invitation(
&self,
input: RejectResourceShareInvitationRequest,
) -> Result<
RejectResourceShareInvitationResponse,
RusotoError<RejectResourceShareInvitationError>,
>;
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_resource_share(
&self,
input: UpdateResourceShareRequest,
) -> Result<UpdateResourceShareResponse, RusotoError<UpdateResourceShareError>>;
}
#[derive(Clone)]
pub struct RamClient {
client: Client,
region: region::Region,
}
impl RamClient {
pub fn new(region: region::Region) -> RamClient {
RamClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> RamClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
RamClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> RamClient {
RamClient { client, region }
}
}
#[async_trait]
impl Ram for RamClient {
#[allow(unused_mut)]
async fn accept_resource_share_invitation(
&self,
input: AcceptResourceShareInvitationRequest,
) -> Result<
AcceptResourceShareInvitationResponse,
RusotoError<AcceptResourceShareInvitationError>,
> {
let request_uri = "/acceptresourceshareinvitation";
let mut request = SignedRequest::new("POST", "ram", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<AcceptResourceShareInvitationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(AcceptResourceShareInvitationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn associate_resource_share(
&self,
input: AssociateResourceShareRequest,
) -> Result<AssociateResourceShareResponse, RusotoError<AssociateResourceShareError>> {
let request_uri = "/associateresourceshare";
let mut request = SignedRequest::new("POST", "ram", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<AssociateResourceShareResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(AssociateResourceShareError::from_response(response))
}
}
#[allow(unused_mut)]
async fn associate_resource_share_permission(
&self,
input: AssociateResourceSharePermissionRequest,
) -> Result<
AssociateResourceSharePermissionResponse,
RusotoError<AssociateResourceSharePermissionError>,
> {
let request_uri = "/associateresourcesharepermission";
let mut request = SignedRequest::new("POST", "ram", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<AssociateResourceSharePermissionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(AssociateResourceSharePermissionError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn create_resource_share(
&self,
input: CreateResourceShareRequest,
) -> Result<CreateResourceShareResponse, RusotoError<CreateResourceShareError>> {
let request_uri = "/createresourceshare";
let mut request = SignedRequest::new("POST", "ram", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateResourceShareResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateResourceShareError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_resource_share(
&self,
input: DeleteResourceShareRequest,
) -> Result<DeleteResourceShareResponse, RusotoError<DeleteResourceShareError>> {
let request_uri = "/deleteresourceshare";
let mut request = SignedRequest::new("DELETE", "ram", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.client_token {
params.put("clientToken", x);
}
params.put("resourceShareArn", &input.resource_share_arn);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteResourceShareResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteResourceShareError::from_response(response))
}
}
#[allow(unused_mut)]
async fn disassociate_resource_share(
&self,
input: DisassociateResourceShareRequest,
) -> Result<DisassociateResourceShareResponse, RusotoError<DisassociateResourceShareError>>
{
let request_uri = "/disassociateresourceshare";
let mut request = SignedRequest::new("POST", "ram", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DisassociateResourceShareResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DisassociateResourceShareError::from_response(response))
}
}
#[allow(unused_mut)]
async fn disassociate_resource_share_permission(
&self,
input: DisassociateResourceSharePermissionRequest,
) -> Result<
DisassociateResourceSharePermissionResponse,
RusotoError<DisassociateResourceSharePermissionError>,
> {
let request_uri = "/disassociateresourcesharepermission";
let mut request = SignedRequest::new("POST", "ram", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DisassociateResourceSharePermissionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DisassociateResourceSharePermissionError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn enable_sharing_with_aws_organization(
&self,
) -> Result<
EnableSharingWithAwsOrganizationResponse,
RusotoError<EnableSharingWithAwsOrganizationError>,
> {
let request_uri = "/enablesharingwithawsorganization";
let mut request = SignedRequest::new("POST", "ram", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<EnableSharingWithAwsOrganizationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(EnableSharingWithAwsOrganizationError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn get_permission(
&self,
input: GetPermissionRequest,
) -> Result<GetPermissionResponse, RusotoError<GetPermissionError>> {
let request_uri = "/getpermission";
let mut request = SignedRequest::new("POST", "ram", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetPermissionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetPermissionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_resource_policies(
&self,
input: GetResourcePoliciesRequest,
) -> Result<GetResourcePoliciesResponse, RusotoError<GetResourcePoliciesError>> {
let request_uri = "/getresourcepolicies";
let mut request = SignedRequest::new("POST", "ram", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetResourcePoliciesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetResourcePoliciesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_resource_share_associations(
&self,
input: GetResourceShareAssociationsRequest,
) -> Result<GetResourceShareAssociationsResponse, RusotoError<GetResourceShareAssociationsError>>
{
let request_uri = "/getresourceshareassociations";
let mut request = SignedRequest::new("POST", "ram", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetResourceShareAssociationsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetResourceShareAssociationsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_resource_share_invitations(
&self,
input: GetResourceShareInvitationsRequest,
) -> Result<GetResourceShareInvitationsResponse, RusotoError<GetResourceShareInvitationsError>>
{
let request_uri = "/getresourceshareinvitations";
let mut request = SignedRequest::new("POST", "ram", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetResourceShareInvitationsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetResourceShareInvitationsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_resource_shares(
&self,
input: GetResourceSharesRequest,
) -> Result<GetResourceSharesResponse, RusotoError<GetResourceSharesError>> {
let request_uri = "/getresourceshares";
let mut request = SignedRequest::new("POST", "ram", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetResourceSharesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetResourceSharesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_pending_invitation_resources(
&self,
input: ListPendingInvitationResourcesRequest,
) -> Result<
ListPendingInvitationResourcesResponse,
RusotoError<ListPendingInvitationResourcesError>,
> {
let request_uri = "/listpendinginvitationresources";
let mut request = SignedRequest::new("POST", "ram", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListPendingInvitationResourcesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListPendingInvitationResourcesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_permissions(
&self,
input: ListPermissionsRequest,
) -> Result<ListPermissionsResponse, RusotoError<ListPermissionsError>> {
let request_uri = "/listpermissions";
let mut request = SignedRequest::new("POST", "ram", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListPermissionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListPermissionsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_principals(
&self,
input: ListPrincipalsRequest,
) -> Result<ListPrincipalsResponse, RusotoError<ListPrincipalsError>> {
let request_uri = "/listprincipals";
let mut request = SignedRequest::new("POST", "ram", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListPrincipalsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListPrincipalsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_resource_share_permissions(
&self,
input: ListResourceSharePermissionsRequest,
) -> Result<ListResourceSharePermissionsResponse, RusotoError<ListResourceSharePermissionsError>>
{
let request_uri = "/listresourcesharepermissions";
let mut request = SignedRequest::new("POST", "ram", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListResourceSharePermissionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListResourceSharePermissionsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_resource_types(
&self,
input: ListResourceTypesRequest,
) -> Result<ListResourceTypesResponse, RusotoError<ListResourceTypesError>> {
let request_uri = "/listresourcetypes";
let mut request = SignedRequest::new("POST", "ram", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListResourceTypesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListResourceTypesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_resources(
&self,
input: ListResourcesRequest,
) -> Result<ListResourcesResponse, RusotoError<ListResourcesError>> {
let request_uri = "/listresources";
let mut request = SignedRequest::new("POST", "ram", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListResourcesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListResourcesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn promote_resource_share_created_from_policy(
&self,
input: PromoteResourceShareCreatedFromPolicyRequest,
) -> Result<
PromoteResourceShareCreatedFromPolicyResponse,
RusotoError<PromoteResourceShareCreatedFromPolicyError>,
> {
let request_uri = "/promoteresourcesharecreatedfrompolicy";
let mut request = SignedRequest::new("POST", "ram", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put("resourceShareArn", &input.resource_share_arn);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PromoteResourceShareCreatedFromPolicyResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PromoteResourceShareCreatedFromPolicyError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn reject_resource_share_invitation(
&self,
input: RejectResourceShareInvitationRequest,
) -> Result<
RejectResourceShareInvitationResponse,
RusotoError<RejectResourceShareInvitationError>,
> {
let request_uri = "/rejectresourceshareinvitation";
let mut request = SignedRequest::new("POST", "ram", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<RejectResourceShareInvitationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(RejectResourceShareInvitationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>> {
let request_uri = "/tagresource";
let mut request = SignedRequest::new("POST", "ram", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<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 = "/untagresource";
let mut request = SignedRequest::new("POST", "ram", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UntagResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UntagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_resource_share(
&self,
input: UpdateResourceShareRequest,
) -> Result<UpdateResourceShareResponse, RusotoError<UpdateResourceShareError>> {
let request_uri = "/updateresourceshare";
let mut request = SignedRequest::new("POST", "ram", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateResourceShareResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateResourceShareError::from_response(response))
}
}
}