use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::proto;
use rusoto_core::request::HttpResponse;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
impl WorkspacesClient {
fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
let mut request = SignedRequest::new(http_method, "workspaces", &self.region, request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request
}
async fn sign_and_dispatch<E>(
&self,
request: SignedRequest,
from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
) -> Result<HttpResponse, RusotoError<E>> {
let mut response = self.client.sign_and_dispatch(request).await?;
if !response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
return Err(from_response(response));
}
Ok(response)
}
}
use serde_json;
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AccountModification {
#[serde(rename = "DedicatedTenancyManagementCidrRange")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dedicated_tenancy_management_cidr_range: Option<String>,
#[serde(rename = "DedicatedTenancySupport")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dedicated_tenancy_support: Option<String>,
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "ModificationState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub modification_state: Option<String>,
#[serde(rename = "StartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AssociateIpGroupsRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "GroupIds")]
pub group_ids: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssociateIpGroupsResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AuthorizeIpRulesRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
#[serde(rename = "UserRules")]
pub user_rules: Vec<IpRuleItem>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AuthorizeIpRulesResult {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ClientProperties {
#[serde(rename = "ReconnectEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reconnect_enabled: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ClientPropertiesResult {
#[serde(rename = "ClientProperties")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_properties: Option<ClientProperties>,
#[serde(rename = "ResourceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ComputeType {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CopyWorkspaceImageRequest {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "SourceImageId")]
pub source_image_id: String,
#[serde(rename = "SourceRegion")]
pub source_region: 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 CopyWorkspaceImageResult {
#[serde(rename = "ImageId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateIpGroupRequest {
#[serde(rename = "GroupDesc")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_desc: Option<String>,
#[serde(rename = "GroupName")]
pub group_name: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "UserRules")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_rules: Option<Vec<IpRuleItem>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateIpGroupResult {
#[serde(rename = "GroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateTagsRequest {
#[serde(rename = "ResourceId")]
pub resource_id: String,
#[serde(rename = "Tags")]
pub tags: Vec<Tag>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateTagsResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateWorkspacesRequest {
#[serde(rename = "Workspaces")]
pub workspaces: Vec<WorkspaceRequest>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateWorkspacesResult {
#[serde(rename = "FailedRequests")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed_requests: Option<Vec<FailedCreateWorkspaceRequest>>,
#[serde(rename = "PendingRequests")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pending_requests: Option<Vec<Workspace>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DefaultWorkspaceCreationProperties {
#[serde(rename = "CustomSecurityGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_security_group_id: Option<String>,
#[serde(rename = "DefaultOu")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_ou: Option<String>,
#[serde(rename = "EnableInternetAccess")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_internet_access: Option<bool>,
#[serde(rename = "EnableMaintenanceMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_maintenance_mode: Option<bool>,
#[serde(rename = "EnableWorkDocs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_work_docs: Option<bool>,
#[serde(rename = "UserEnabledAsLocalAdministrator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_enabled_as_local_administrator: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteIpGroupRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteIpGroupResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteTagsRequest {
#[serde(rename = "ResourceId")]
pub resource_id: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteTagsResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteWorkspaceImageRequest {
#[serde(rename = "ImageId")]
pub image_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteWorkspaceImageResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeregisterWorkspaceDirectoryRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeregisterWorkspaceDirectoryResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeAccountModificationsRequest {
#[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 DescribeAccountModificationsResult {
#[serde(rename = "AccountModifications")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_modifications: Option<Vec<AccountModification>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeAccountRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeAccountResult {
#[serde(rename = "DedicatedTenancyManagementCidrRange")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dedicated_tenancy_management_cidr_range: Option<String>,
#[serde(rename = "DedicatedTenancySupport")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dedicated_tenancy_support: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeClientPropertiesRequest {
#[serde(rename = "ResourceIds")]
pub resource_ids: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeClientPropertiesResult {
#[serde(rename = "ClientPropertiesList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_properties_list: Option<Vec<ClientPropertiesResult>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeIpGroupsRequest {
#[serde(rename = "GroupIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_ids: Option<Vec<String>>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeIpGroupsResult {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Result")]
#[serde(skip_serializing_if = "Option::is_none")]
pub result: Option<Vec<WorkspacesIpGroup>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeTagsRequest {
#[serde(rename = "ResourceId")]
pub resource_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeTagsResult {
#[serde(rename = "TagList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tag_list: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeWorkspaceBundlesRequest {
#[serde(rename = "BundleIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bundle_ids: Option<Vec<String>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Owner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeWorkspaceBundlesResult {
#[serde(rename = "Bundles")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bundles: Option<Vec<WorkspaceBundle>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeWorkspaceDirectoriesRequest {
#[serde(rename = "DirectoryIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_ids: Option<Vec<String>>,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeWorkspaceDirectoriesResult {
#[serde(rename = "Directories")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directories: Option<Vec<WorkspaceDirectory>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeWorkspaceImagesRequest {
#[serde(rename = "ImageIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_ids: Option<Vec<String>>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeWorkspaceImagesResult {
#[serde(rename = "Images")]
#[serde(skip_serializing_if = "Option::is_none")]
pub images: Option<Vec<WorkspaceImage>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeWorkspaceSnapshotsRequest {
#[serde(rename = "WorkspaceId")]
pub workspace_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeWorkspaceSnapshotsResult {
#[serde(rename = "RebuildSnapshots")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rebuild_snapshots: Option<Vec<Snapshot>>,
#[serde(rename = "RestoreSnapshots")]
#[serde(skip_serializing_if = "Option::is_none")]
pub restore_snapshots: Option<Vec<Snapshot>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeWorkspacesConnectionStatusRequest {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "WorkspaceIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub workspace_ids: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeWorkspacesConnectionStatusResult {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "WorkspacesConnectionStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub workspaces_connection_status: Option<Vec<WorkspaceConnectionStatus>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeWorkspacesRequest {
#[serde(rename = "BundleId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bundle_id: Option<String>,
#[serde(rename = "DirectoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_id: Option<String>,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "UserName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_name: Option<String>,
#[serde(rename = "WorkspaceIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub workspace_ids: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeWorkspacesResult {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Workspaces")]
#[serde(skip_serializing_if = "Option::is_none")]
pub workspaces: Option<Vec<Workspace>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisassociateIpGroupsRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "GroupIds")]
pub group_ids: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisassociateIpGroupsResult {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FailedCreateWorkspaceRequest {
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "WorkspaceRequest")]
#[serde(skip_serializing_if = "Option::is_none")]
pub workspace_request: Option<WorkspaceRequest>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FailedWorkspaceChangeRequest {
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "WorkspaceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub workspace_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ImportWorkspaceImageRequest {
#[serde(rename = "Ec2ImageId")]
pub ec_2_image_id: String,
#[serde(rename = "ImageDescription")]
pub image_description: String,
#[serde(rename = "ImageName")]
pub image_name: String,
#[serde(rename = "IngestionProcess")]
pub ingestion_process: 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 ImportWorkspaceImageResult {
#[serde(rename = "ImageId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct IpRuleItem {
#[serde(rename = "ipRule")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_rule: Option<String>,
#[serde(rename = "ruleDesc")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rule_desc: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListAvailableManagementCidrRangesRequest {
#[serde(rename = "ManagementCidrRangeConstraint")]
pub management_cidr_range_constraint: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListAvailableManagementCidrRangesResult {
#[serde(rename = "ManagementCidrRanges")]
#[serde(skip_serializing_if = "Option::is_none")]
pub management_cidr_ranges: Option<Vec<String>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct MigrateWorkspaceRequest {
#[serde(rename = "BundleId")]
pub bundle_id: String,
#[serde(rename = "SourceWorkspaceId")]
pub source_workspace_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MigrateWorkspaceResult {
#[serde(rename = "SourceWorkspaceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_workspace_id: Option<String>,
#[serde(rename = "TargetWorkspaceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_workspace_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ModificationState {
#[serde(rename = "Resource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource: Option<String>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ModifyAccountRequest {
#[serde(rename = "DedicatedTenancyManagementCidrRange")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dedicated_tenancy_management_cidr_range: Option<String>,
#[serde(rename = "DedicatedTenancySupport")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dedicated_tenancy_support: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ModifyAccountResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ModifyClientPropertiesRequest {
#[serde(rename = "ClientProperties")]
pub client_properties: ClientProperties,
#[serde(rename = "ResourceId")]
pub resource_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ModifyClientPropertiesResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ModifySelfservicePermissionsRequest {
#[serde(rename = "ResourceId")]
pub resource_id: String,
#[serde(rename = "SelfservicePermissions")]
pub selfservice_permissions: SelfservicePermissions,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ModifySelfservicePermissionsResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ModifyWorkspaceAccessPropertiesRequest {
#[serde(rename = "ResourceId")]
pub resource_id: String,
#[serde(rename = "WorkspaceAccessProperties")]
pub workspace_access_properties: WorkspaceAccessProperties,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ModifyWorkspaceAccessPropertiesResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ModifyWorkspaceCreationPropertiesRequest {
#[serde(rename = "ResourceId")]
pub resource_id: String,
#[serde(rename = "WorkspaceCreationProperties")]
pub workspace_creation_properties: WorkspaceCreationProperties,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ModifyWorkspaceCreationPropertiesResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ModifyWorkspacePropertiesRequest {
#[serde(rename = "WorkspaceId")]
pub workspace_id: String,
#[serde(rename = "WorkspaceProperties")]
pub workspace_properties: WorkspaceProperties,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ModifyWorkspacePropertiesResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ModifyWorkspaceStateRequest {
#[serde(rename = "WorkspaceId")]
pub workspace_id: String,
#[serde(rename = "WorkspaceState")]
pub workspace_state: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ModifyWorkspaceStateResult {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct OperatingSystem {
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RebootRequest {
#[serde(rename = "WorkspaceId")]
pub workspace_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RebootWorkspacesRequest {
#[serde(rename = "RebootWorkspaceRequests")]
pub reboot_workspace_requests: Vec<RebootRequest>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RebootWorkspacesResult {
#[serde(rename = "FailedRequests")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed_requests: Option<Vec<FailedWorkspaceChangeRequest>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RebuildRequest {
#[serde(rename = "WorkspaceId")]
pub workspace_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RebuildWorkspacesRequest {
#[serde(rename = "RebuildWorkspaceRequests")]
pub rebuild_workspace_requests: Vec<RebuildRequest>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RebuildWorkspacesResult {
#[serde(rename = "FailedRequests")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed_requests: Option<Vec<FailedWorkspaceChangeRequest>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RegisterWorkspaceDirectoryRequest {
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "EnableSelfService")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_self_service: Option<bool>,
#[serde(rename = "EnableWorkDocs")]
pub enable_work_docs: bool,
#[serde(rename = "SubnetIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_ids: Option<Vec<String>>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "Tenancy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tenancy: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RegisterWorkspaceDirectoryResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RestoreWorkspaceRequest {
#[serde(rename = "WorkspaceId")]
pub workspace_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RestoreWorkspaceResult {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RevokeIpRulesRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
#[serde(rename = "UserRules")]
pub user_rules: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RevokeIpRulesResult {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RootStorage {
#[serde(rename = "Capacity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub capacity: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SelfservicePermissions {
#[serde(rename = "ChangeComputeType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub change_compute_type: Option<String>,
#[serde(rename = "IncreaseVolumeSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub increase_volume_size: Option<String>,
#[serde(rename = "RebuildWorkspace")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rebuild_workspace: Option<String>,
#[serde(rename = "RestartWorkspace")]
#[serde(skip_serializing_if = "Option::is_none")]
pub restart_workspace: Option<String>,
#[serde(rename = "SwitchRunningMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub switch_running_mode: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Snapshot {
#[serde(rename = "SnapshotTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snapshot_time: Option<f64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartRequest {
#[serde(rename = "WorkspaceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub workspace_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartWorkspacesRequest {
#[serde(rename = "StartWorkspaceRequests")]
pub start_workspace_requests: Vec<StartRequest>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartWorkspacesResult {
#[serde(rename = "FailedRequests")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed_requests: Option<Vec<FailedWorkspaceChangeRequest>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopRequest {
#[serde(rename = "WorkspaceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub workspace_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopWorkspacesRequest {
#[serde(rename = "StopWorkspaceRequests")]
pub stop_workspace_requests: Vec<StopRequest>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StopWorkspacesResult {
#[serde(rename = "FailedRequests")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed_requests: Option<Vec<FailedWorkspaceChangeRequest>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Tag {
#[serde(rename = "Key")]
pub key: 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 TerminateRequest {
#[serde(rename = "WorkspaceId")]
pub workspace_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TerminateWorkspacesRequest {
#[serde(rename = "TerminateWorkspaceRequests")]
pub terminate_workspace_requests: Vec<TerminateRequest>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TerminateWorkspacesResult {
#[serde(rename = "FailedRequests")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed_requests: Option<Vec<FailedWorkspaceChangeRequest>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateRulesOfIpGroupRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
#[serde(rename = "UserRules")]
pub user_rules: Vec<IpRuleItem>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateRulesOfIpGroupResult {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UserStorage {
#[serde(rename = "Capacity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub capacity: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Workspace {
#[serde(rename = "BundleId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bundle_id: Option<String>,
#[serde(rename = "ComputerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub computer_name: Option<String>,
#[serde(rename = "DirectoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_id: Option<String>,
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "IpAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_address: Option<String>,
#[serde(rename = "ModificationStates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub modification_states: Option<Vec<ModificationState>>,
#[serde(rename = "RootVolumeEncryptionEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub root_volume_encryption_enabled: Option<bool>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "SubnetId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_id: Option<String>,
#[serde(rename = "UserName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_name: Option<String>,
#[serde(rename = "UserVolumeEncryptionEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_volume_encryption_enabled: Option<bool>,
#[serde(rename = "VolumeEncryptionKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_encryption_key: Option<String>,
#[serde(rename = "WorkspaceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub workspace_id: Option<String>,
#[serde(rename = "WorkspaceProperties")]
#[serde(skip_serializing_if = "Option::is_none")]
pub workspace_properties: Option<WorkspaceProperties>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct WorkspaceAccessProperties {
#[serde(rename = "DeviceTypeAndroid")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_type_android: Option<String>,
#[serde(rename = "DeviceTypeChromeOs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_type_chrome_os: Option<String>,
#[serde(rename = "DeviceTypeIos")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_type_ios: Option<String>,
#[serde(rename = "DeviceTypeOsx")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_type_osx: Option<String>,
#[serde(rename = "DeviceTypeWeb")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_type_web: Option<String>,
#[serde(rename = "DeviceTypeWindows")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_type_windows: Option<String>,
#[serde(rename = "DeviceTypeZeroClient")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_type_zero_client: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct WorkspaceBundle {
#[serde(rename = "BundleId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bundle_id: Option<String>,
#[serde(rename = "ComputeType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compute_type: Option<ComputeType>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "ImageId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_id: 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 = "Owner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner: Option<String>,
#[serde(rename = "RootStorage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub root_storage: Option<RootStorage>,
#[serde(rename = "UserStorage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_storage: Option<UserStorage>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct WorkspaceConnectionStatus {
#[serde(rename = "ConnectionState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_state: Option<String>,
#[serde(rename = "ConnectionStateCheckTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_state_check_timestamp: Option<f64>,
#[serde(rename = "LastKnownUserConnectionTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_known_user_connection_timestamp: Option<f64>,
#[serde(rename = "WorkspaceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub workspace_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct WorkspaceCreationProperties {
#[serde(rename = "CustomSecurityGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_security_group_id: Option<String>,
#[serde(rename = "DefaultOu")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_ou: Option<String>,
#[serde(rename = "EnableInternetAccess")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_internet_access: Option<bool>,
#[serde(rename = "EnableMaintenanceMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_maintenance_mode: Option<bool>,
#[serde(rename = "UserEnabledAsLocalAdministrator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_enabled_as_local_administrator: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct WorkspaceDirectory {
#[serde(rename = "Alias")]
#[serde(skip_serializing_if = "Option::is_none")]
pub alias: Option<String>,
#[serde(rename = "CustomerUserName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_user_name: Option<String>,
#[serde(rename = "DirectoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_id: Option<String>,
#[serde(rename = "DirectoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_name: Option<String>,
#[serde(rename = "DirectoryType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_type: Option<String>,
#[serde(rename = "DnsIpAddresses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dns_ip_addresses: Option<Vec<String>>,
#[serde(rename = "IamRoleId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_role_id: Option<String>,
#[serde(rename = "RegistrationCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub registration_code: Option<String>,
#[serde(rename = "SelfservicePermissions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub selfservice_permissions: Option<SelfservicePermissions>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "SubnetIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_ids: Option<Vec<String>>,
#[serde(rename = "Tenancy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tenancy: Option<String>,
#[serde(rename = "WorkspaceAccessProperties")]
#[serde(skip_serializing_if = "Option::is_none")]
pub workspace_access_properties: Option<WorkspaceAccessProperties>,
#[serde(rename = "WorkspaceCreationProperties")]
#[serde(skip_serializing_if = "Option::is_none")]
pub workspace_creation_properties: Option<DefaultWorkspaceCreationProperties>,
#[serde(rename = "WorkspaceSecurityGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub workspace_security_group_id: Option<String>,
#[serde(rename = "ipGroupIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_group_ids: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct WorkspaceImage {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "ImageId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "OperatingSystem")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operating_system: Option<OperatingSystem>,
#[serde(rename = "RequiredTenancy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub required_tenancy: Option<String>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct WorkspaceProperties {
#[serde(rename = "ComputeTypeName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compute_type_name: Option<String>,
#[serde(rename = "RootVolumeSizeGib")]
#[serde(skip_serializing_if = "Option::is_none")]
pub root_volume_size_gib: Option<i64>,
#[serde(rename = "RunningMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub running_mode: Option<String>,
#[serde(rename = "RunningModeAutoStopTimeoutInMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub running_mode_auto_stop_timeout_in_minutes: Option<i64>,
#[serde(rename = "UserVolumeSizeGib")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_volume_size_gib: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct WorkspaceRequest {
#[serde(rename = "BundleId")]
pub bundle_id: String,
#[serde(rename = "DirectoryId")]
pub directory_id: String,
#[serde(rename = "RootVolumeEncryptionEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub root_volume_encryption_enabled: Option<bool>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "UserName")]
pub user_name: String,
#[serde(rename = "UserVolumeEncryptionEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_volume_encryption_enabled: Option<bool>,
#[serde(rename = "VolumeEncryptionKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_encryption_key: Option<String>,
#[serde(rename = "WorkspaceProperties")]
#[serde(skip_serializing_if = "Option::is_none")]
pub workspace_properties: Option<WorkspaceProperties>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct WorkspacesIpGroup {
#[serde(rename = "groupDesc")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_desc: Option<String>,
#[serde(rename = "groupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_id: Option<String>,
#[serde(rename = "groupName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_name: Option<String>,
#[serde(rename = "userRules")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_rules: Option<Vec<IpRuleItem>>,
}
#[derive(Debug, PartialEq)]
pub enum AssociateIpGroupsError {
AccessDenied(String),
InvalidParameterValues(String),
InvalidResourceState(String),
OperationNotSupported(String),
ResourceLimitExceeded(String),
ResourceNotFound(String),
}
impl AssociateIpGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AssociateIpGroupsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(AssociateIpGroupsError::AccessDenied(err.msg))
}
"InvalidParameterValuesException" => {
return RusotoError::Service(AssociateIpGroupsError::InvalidParameterValues(
err.msg,
))
}
"InvalidResourceStateException" => {
return RusotoError::Service(AssociateIpGroupsError::InvalidResourceState(
err.msg,
))
}
"OperationNotSupportedException" => {
return RusotoError::Service(AssociateIpGroupsError::OperationNotSupported(
err.msg,
))
}
"ResourceLimitExceededException" => {
return RusotoError::Service(AssociateIpGroupsError::ResourceLimitExceeded(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AssociateIpGroupsError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociateIpGroupsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociateIpGroupsError::AccessDenied(ref cause) => write!(f, "{}", cause),
AssociateIpGroupsError::InvalidParameterValues(ref cause) => write!(f, "{}", cause),
AssociateIpGroupsError::InvalidResourceState(ref cause) => write!(f, "{}", cause),
AssociateIpGroupsError::OperationNotSupported(ref cause) => write!(f, "{}", cause),
AssociateIpGroupsError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
AssociateIpGroupsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AssociateIpGroupsError {}
#[derive(Debug, PartialEq)]
pub enum AuthorizeIpRulesError {
AccessDenied(String),
InvalidParameterValues(String),
InvalidResourceState(String),
ResourceLimitExceeded(String),
ResourceNotFound(String),
}
impl AuthorizeIpRulesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AuthorizeIpRulesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(AuthorizeIpRulesError::AccessDenied(err.msg))
}
"InvalidParameterValuesException" => {
return RusotoError::Service(AuthorizeIpRulesError::InvalidParameterValues(
err.msg,
))
}
"InvalidResourceStateException" => {
return RusotoError::Service(AuthorizeIpRulesError::InvalidResourceState(
err.msg,
))
}
"ResourceLimitExceededException" => {
return RusotoError::Service(AuthorizeIpRulesError::ResourceLimitExceeded(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AuthorizeIpRulesError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AuthorizeIpRulesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AuthorizeIpRulesError::AccessDenied(ref cause) => write!(f, "{}", cause),
AuthorizeIpRulesError::InvalidParameterValues(ref cause) => write!(f, "{}", cause),
AuthorizeIpRulesError::InvalidResourceState(ref cause) => write!(f, "{}", cause),
AuthorizeIpRulesError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
AuthorizeIpRulesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AuthorizeIpRulesError {}
#[derive(Debug, PartialEq)]
pub enum CopyWorkspaceImageError {
AccessDenied(String),
InvalidParameterValues(String),
OperationNotSupported(String),
ResourceAlreadyExists(String),
ResourceLimitExceeded(String),
ResourceNotFound(String),
ResourceUnavailable(String),
}
impl CopyWorkspaceImageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CopyWorkspaceImageError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CopyWorkspaceImageError::AccessDenied(err.msg))
}
"InvalidParameterValuesException" => {
return RusotoError::Service(CopyWorkspaceImageError::InvalidParameterValues(
err.msg,
))
}
"OperationNotSupportedException" => {
return RusotoError::Service(CopyWorkspaceImageError::OperationNotSupported(
err.msg,
))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(CopyWorkspaceImageError::ResourceAlreadyExists(
err.msg,
))
}
"ResourceLimitExceededException" => {
return RusotoError::Service(CopyWorkspaceImageError::ResourceLimitExceeded(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CopyWorkspaceImageError::ResourceNotFound(err.msg))
}
"ResourceUnavailableException" => {
return RusotoError::Service(CopyWorkspaceImageError::ResourceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CopyWorkspaceImageError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CopyWorkspaceImageError::AccessDenied(ref cause) => write!(f, "{}", cause),
CopyWorkspaceImageError::InvalidParameterValues(ref cause) => write!(f, "{}", cause),
CopyWorkspaceImageError::OperationNotSupported(ref cause) => write!(f, "{}", cause),
CopyWorkspaceImageError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
CopyWorkspaceImageError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
CopyWorkspaceImageError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CopyWorkspaceImageError::ResourceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CopyWorkspaceImageError {}
#[derive(Debug, PartialEq)]
pub enum CreateIpGroupError {
AccessDenied(String),
InvalidParameterValues(String),
ResourceAlreadyExists(String),
ResourceCreationFailed(String),
ResourceLimitExceeded(String),
}
impl CreateIpGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateIpGroupError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateIpGroupError::AccessDenied(err.msg))
}
"InvalidParameterValuesException" => {
return RusotoError::Service(CreateIpGroupError::InvalidParameterValues(
err.msg,
))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(CreateIpGroupError::ResourceAlreadyExists(err.msg))
}
"ResourceCreationFailedException" => {
return RusotoError::Service(CreateIpGroupError::ResourceCreationFailed(
err.msg,
))
}
"ResourceLimitExceededException" => {
return RusotoError::Service(CreateIpGroupError::ResourceLimitExceeded(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateIpGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateIpGroupError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateIpGroupError::InvalidParameterValues(ref cause) => write!(f, "{}", cause),
CreateIpGroupError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateIpGroupError::ResourceCreationFailed(ref cause) => write!(f, "{}", cause),
CreateIpGroupError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateIpGroupError {}
#[derive(Debug, PartialEq)]
pub enum CreateTagsError {
InvalidParameterValues(String),
ResourceLimitExceeded(String),
ResourceNotFound(String),
}
impl CreateTagsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateTagsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParameterValuesException" => {
return RusotoError::Service(CreateTagsError::InvalidParameterValues(err.msg))
}
"ResourceLimitExceededException" => {
return RusotoError::Service(CreateTagsError::ResourceLimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateTagsError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateTagsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateTagsError::InvalidParameterValues(ref cause) => write!(f, "{}", cause),
CreateTagsError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateTagsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateTagsError {}
#[derive(Debug, PartialEq)]
pub enum CreateWorkspacesError {
InvalidParameterValues(String),
ResourceLimitExceeded(String),
}
impl CreateWorkspacesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateWorkspacesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParameterValuesException" => {
return RusotoError::Service(CreateWorkspacesError::InvalidParameterValues(
err.msg,
))
}
"ResourceLimitExceededException" => {
return RusotoError::Service(CreateWorkspacesError::ResourceLimitExceeded(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateWorkspacesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateWorkspacesError::InvalidParameterValues(ref cause) => write!(f, "{}", cause),
CreateWorkspacesError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateWorkspacesError {}
#[derive(Debug, PartialEq)]
pub enum DeleteIpGroupError {
AccessDenied(String),
InvalidParameterValues(String),
ResourceAssociated(String),
ResourceNotFound(String),
}
impl DeleteIpGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteIpGroupError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteIpGroupError::AccessDenied(err.msg))
}
"InvalidParameterValuesException" => {
return RusotoError::Service(DeleteIpGroupError::InvalidParameterValues(
err.msg,
))
}
"ResourceAssociatedException" => {
return RusotoError::Service(DeleteIpGroupError::ResourceAssociated(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteIpGroupError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteIpGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteIpGroupError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteIpGroupError::InvalidParameterValues(ref cause) => write!(f, "{}", cause),
DeleteIpGroupError::ResourceAssociated(ref cause) => write!(f, "{}", cause),
DeleteIpGroupError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteIpGroupError {}
#[derive(Debug, PartialEq)]
pub enum DeleteTagsError {
InvalidParameterValues(String),
ResourceNotFound(String),
}
impl DeleteTagsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteTagsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParameterValuesException" => {
return RusotoError::Service(DeleteTagsError::InvalidParameterValues(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteTagsError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteTagsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteTagsError::InvalidParameterValues(ref cause) => write!(f, "{}", cause),
DeleteTagsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteTagsError {}
#[derive(Debug, PartialEq)]
pub enum DeleteWorkspaceImageError {
AccessDenied(String),
InvalidResourceState(String),
ResourceAssociated(String),
}
impl DeleteWorkspaceImageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteWorkspaceImageError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteWorkspaceImageError::AccessDenied(err.msg))
}
"InvalidResourceStateException" => {
return RusotoError::Service(DeleteWorkspaceImageError::InvalidResourceState(
err.msg,
))
}
"ResourceAssociatedException" => {
return RusotoError::Service(DeleteWorkspaceImageError::ResourceAssociated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteWorkspaceImageError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteWorkspaceImageError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteWorkspaceImageError::InvalidResourceState(ref cause) => write!(f, "{}", cause),
DeleteWorkspaceImageError::ResourceAssociated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteWorkspaceImageError {}
#[derive(Debug, PartialEq)]
pub enum DeregisterWorkspaceDirectoryError {
AccessDenied(String),
InvalidParameterValues(String),
InvalidResourceState(String),
OperationNotSupported(String),
ResourceNotFound(String),
}
impl DeregisterWorkspaceDirectoryError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeregisterWorkspaceDirectoryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeregisterWorkspaceDirectoryError::AccessDenied(
err.msg,
))
}
"InvalidParameterValuesException" => {
return RusotoError::Service(
DeregisterWorkspaceDirectoryError::InvalidParameterValues(err.msg),
)
}
"InvalidResourceStateException" => {
return RusotoError::Service(
DeregisterWorkspaceDirectoryError::InvalidResourceState(err.msg),
)
}
"OperationNotSupportedException" => {
return RusotoError::Service(
DeregisterWorkspaceDirectoryError::OperationNotSupported(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DeregisterWorkspaceDirectoryError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeregisterWorkspaceDirectoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeregisterWorkspaceDirectoryError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeregisterWorkspaceDirectoryError::InvalidParameterValues(ref cause) => {
write!(f, "{}", cause)
}
DeregisterWorkspaceDirectoryError::InvalidResourceState(ref cause) => {
write!(f, "{}", cause)
}
DeregisterWorkspaceDirectoryError::OperationNotSupported(ref cause) => {
write!(f, "{}", cause)
}
DeregisterWorkspaceDirectoryError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeregisterWorkspaceDirectoryError {}
#[derive(Debug, PartialEq)]
pub enum DescribeAccountError {
AccessDenied(String),
}
impl DescribeAccountError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeAccountError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DescribeAccountError::AccessDenied(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeAccountError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeAccountError::AccessDenied(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeAccountError {}
#[derive(Debug, PartialEq)]
pub enum DescribeAccountModificationsError {
AccessDenied(String),
}
impl DescribeAccountModificationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeAccountModificationsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DescribeAccountModificationsError::AccessDenied(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeAccountModificationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeAccountModificationsError::AccessDenied(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeAccountModificationsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeClientPropertiesError {
AccessDenied(String),
InvalidParameterValues(String),
ResourceNotFound(String),
}
impl DescribeClientPropertiesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeClientPropertiesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DescribeClientPropertiesError::AccessDenied(
err.msg,
))
}
"InvalidParameterValuesException" => {
return RusotoError::Service(
DescribeClientPropertiesError::InvalidParameterValues(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeClientPropertiesError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeClientPropertiesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeClientPropertiesError::AccessDenied(ref cause) => write!(f, "{}", cause),
DescribeClientPropertiesError::InvalidParameterValues(ref cause) => {
write!(f, "{}", cause)
}
DescribeClientPropertiesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeClientPropertiesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeIpGroupsError {
AccessDenied(String),
InvalidParameterValues(String),
}
impl DescribeIpGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeIpGroupsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DescribeIpGroupsError::AccessDenied(err.msg))
}
"InvalidParameterValuesException" => {
return RusotoError::Service(DescribeIpGroupsError::InvalidParameterValues(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeIpGroupsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeIpGroupsError::AccessDenied(ref cause) => write!(f, "{}", cause),
DescribeIpGroupsError::InvalidParameterValues(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeIpGroupsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeTagsError {
ResourceNotFound(String),
}
impl DescribeTagsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeTagsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeTagsError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeTagsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeTagsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeTagsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeWorkspaceBundlesError {
InvalidParameterValues(String),
}
impl DescribeWorkspaceBundlesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeWorkspaceBundlesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParameterValuesException" => {
return RusotoError::Service(
DescribeWorkspaceBundlesError::InvalidParameterValues(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeWorkspaceBundlesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeWorkspaceBundlesError::InvalidParameterValues(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeWorkspaceBundlesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeWorkspaceDirectoriesError {
InvalidParameterValues(String),
}
impl DescribeWorkspaceDirectoriesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeWorkspaceDirectoriesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParameterValuesException" => {
return RusotoError::Service(
DescribeWorkspaceDirectoriesError::InvalidParameterValues(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeWorkspaceDirectoriesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeWorkspaceDirectoriesError::InvalidParameterValues(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeWorkspaceDirectoriesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeWorkspaceImagesError {
AccessDenied(String),
}
impl DescribeWorkspaceImagesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeWorkspaceImagesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DescribeWorkspaceImagesError::AccessDenied(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeWorkspaceImagesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeWorkspaceImagesError::AccessDenied(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeWorkspaceImagesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeWorkspaceSnapshotsError {
AccessDenied(String),
InvalidParameterValues(String),
ResourceNotFound(String),
}
impl DescribeWorkspaceSnapshotsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeWorkspaceSnapshotsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DescribeWorkspaceSnapshotsError::AccessDenied(
err.msg,
))
}
"InvalidParameterValuesException" => {
return RusotoError::Service(
DescribeWorkspaceSnapshotsError::InvalidParameterValues(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeWorkspaceSnapshotsError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeWorkspaceSnapshotsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeWorkspaceSnapshotsError::AccessDenied(ref cause) => write!(f, "{}", cause),
DescribeWorkspaceSnapshotsError::InvalidParameterValues(ref cause) => {
write!(f, "{}", cause)
}
DescribeWorkspaceSnapshotsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeWorkspaceSnapshotsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeWorkspacesError {
InvalidParameterValues(String),
ResourceUnavailable(String),
}
impl DescribeWorkspacesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeWorkspacesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParameterValuesException" => {
return RusotoError::Service(DescribeWorkspacesError::InvalidParameterValues(
err.msg,
))
}
"ResourceUnavailableException" => {
return RusotoError::Service(DescribeWorkspacesError::ResourceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeWorkspacesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeWorkspacesError::InvalidParameterValues(ref cause) => write!(f, "{}", cause),
DescribeWorkspacesError::ResourceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeWorkspacesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeWorkspacesConnectionStatusError {
InvalidParameterValues(String),
}
impl DescribeWorkspacesConnectionStatusError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeWorkspacesConnectionStatusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParameterValuesException" => {
return RusotoError::Service(
DescribeWorkspacesConnectionStatusError::InvalidParameterValues(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeWorkspacesConnectionStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeWorkspacesConnectionStatusError::InvalidParameterValues(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeWorkspacesConnectionStatusError {}
#[derive(Debug, PartialEq)]
pub enum DisassociateIpGroupsError {
AccessDenied(String),
InvalidParameterValues(String),
InvalidResourceState(String),
ResourceNotFound(String),
}
impl DisassociateIpGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DisassociateIpGroupsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DisassociateIpGroupsError::AccessDenied(err.msg))
}
"InvalidParameterValuesException" => {
return RusotoError::Service(DisassociateIpGroupsError::InvalidParameterValues(
err.msg,
))
}
"InvalidResourceStateException" => {
return RusotoError::Service(DisassociateIpGroupsError::InvalidResourceState(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DisassociateIpGroupsError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisassociateIpGroupsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisassociateIpGroupsError::AccessDenied(ref cause) => write!(f, "{}", cause),
DisassociateIpGroupsError::InvalidParameterValues(ref cause) => write!(f, "{}", cause),
DisassociateIpGroupsError::InvalidResourceState(ref cause) => write!(f, "{}", cause),
DisassociateIpGroupsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DisassociateIpGroupsError {}
#[derive(Debug, PartialEq)]
pub enum ImportWorkspaceImageError {
AccessDenied(String),
InvalidParameterValues(String),
OperationNotSupported(String),
ResourceAlreadyExists(String),
ResourceLimitExceeded(String),
ResourceNotFound(String),
}
impl ImportWorkspaceImageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ImportWorkspaceImageError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ImportWorkspaceImageError::AccessDenied(err.msg))
}
"InvalidParameterValuesException" => {
return RusotoError::Service(ImportWorkspaceImageError::InvalidParameterValues(
err.msg,
))
}
"OperationNotSupportedException" => {
return RusotoError::Service(ImportWorkspaceImageError::OperationNotSupported(
err.msg,
))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(ImportWorkspaceImageError::ResourceAlreadyExists(
err.msg,
))
}
"ResourceLimitExceededException" => {
return RusotoError::Service(ImportWorkspaceImageError::ResourceLimitExceeded(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ImportWorkspaceImageError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ImportWorkspaceImageError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ImportWorkspaceImageError::AccessDenied(ref cause) => write!(f, "{}", cause),
ImportWorkspaceImageError::InvalidParameterValues(ref cause) => write!(f, "{}", cause),
ImportWorkspaceImageError::OperationNotSupported(ref cause) => write!(f, "{}", cause),
ImportWorkspaceImageError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
ImportWorkspaceImageError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
ImportWorkspaceImageError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ImportWorkspaceImageError {}
#[derive(Debug, PartialEq)]
pub enum ListAvailableManagementCidrRangesError {
AccessDenied(String),
InvalidParameterValues(String),
}
impl ListAvailableManagementCidrRangesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListAvailableManagementCidrRangesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
ListAvailableManagementCidrRangesError::AccessDenied(err.msg),
)
}
"InvalidParameterValuesException" => {
return RusotoError::Service(
ListAvailableManagementCidrRangesError::InvalidParameterValues(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListAvailableManagementCidrRangesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListAvailableManagementCidrRangesError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
ListAvailableManagementCidrRangesError::InvalidParameterValues(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListAvailableManagementCidrRangesError {}
#[derive(Debug, PartialEq)]
pub enum MigrateWorkspaceError {
AccessDenied(String),
InvalidParameterValues(String),
OperationInProgress(String),
OperationNotSupported(String),
ResourceNotFound(String),
ResourceUnavailable(String),
}
impl MigrateWorkspaceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<MigrateWorkspaceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(MigrateWorkspaceError::AccessDenied(err.msg))
}
"InvalidParameterValuesException" => {
return RusotoError::Service(MigrateWorkspaceError::InvalidParameterValues(
err.msg,
))
}
"OperationInProgressException" => {
return RusotoError::Service(MigrateWorkspaceError::OperationInProgress(
err.msg,
))
}
"OperationNotSupportedException" => {
return RusotoError::Service(MigrateWorkspaceError::OperationNotSupported(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(MigrateWorkspaceError::ResourceNotFound(err.msg))
}
"ResourceUnavailableException" => {
return RusotoError::Service(MigrateWorkspaceError::ResourceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for MigrateWorkspaceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
MigrateWorkspaceError::AccessDenied(ref cause) => write!(f, "{}", cause),
MigrateWorkspaceError::InvalidParameterValues(ref cause) => write!(f, "{}", cause),
MigrateWorkspaceError::OperationInProgress(ref cause) => write!(f, "{}", cause),
MigrateWorkspaceError::OperationNotSupported(ref cause) => write!(f, "{}", cause),
MigrateWorkspaceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
MigrateWorkspaceError::ResourceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for MigrateWorkspaceError {}
#[derive(Debug, PartialEq)]
pub enum ModifyAccountError {
AccessDenied(String),
InvalidParameterValues(String),
InvalidResourceState(String),
ResourceNotFound(String),
ResourceUnavailable(String),
}
impl ModifyAccountError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyAccountError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ModifyAccountError::AccessDenied(err.msg))
}
"InvalidParameterValuesException" => {
return RusotoError::Service(ModifyAccountError::InvalidParameterValues(
err.msg,
))
}
"InvalidResourceStateException" => {
return RusotoError::Service(ModifyAccountError::InvalidResourceState(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ModifyAccountError::ResourceNotFound(err.msg))
}
"ResourceUnavailableException" => {
return RusotoError::Service(ModifyAccountError::ResourceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ModifyAccountError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifyAccountError::AccessDenied(ref cause) => write!(f, "{}", cause),
ModifyAccountError::InvalidParameterValues(ref cause) => write!(f, "{}", cause),
ModifyAccountError::InvalidResourceState(ref cause) => write!(f, "{}", cause),
ModifyAccountError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ModifyAccountError::ResourceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ModifyAccountError {}
#[derive(Debug, PartialEq)]
pub enum ModifyClientPropertiesError {
AccessDenied(String),
InvalidParameterValues(String),
ResourceNotFound(String),
}
impl ModifyClientPropertiesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyClientPropertiesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ModifyClientPropertiesError::AccessDenied(err.msg))
}
"InvalidParameterValuesException" => {
return RusotoError::Service(
ModifyClientPropertiesError::InvalidParameterValues(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(ModifyClientPropertiesError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ModifyClientPropertiesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifyClientPropertiesError::AccessDenied(ref cause) => write!(f, "{}", cause),
ModifyClientPropertiesError::InvalidParameterValues(ref cause) => {
write!(f, "{}", cause)
}
ModifyClientPropertiesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ModifyClientPropertiesError {}
#[derive(Debug, PartialEq)]
pub enum ModifySelfservicePermissionsError {
AccessDenied(String),
InvalidParameterValues(String),
ResourceNotFound(String),
}
impl ModifySelfservicePermissionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ModifySelfservicePermissionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ModifySelfservicePermissionsError::AccessDenied(
err.msg,
))
}
"InvalidParameterValuesException" => {
return RusotoError::Service(
ModifySelfservicePermissionsError::InvalidParameterValues(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
ModifySelfservicePermissionsError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ModifySelfservicePermissionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifySelfservicePermissionsError::AccessDenied(ref cause) => write!(f, "{}", cause),
ModifySelfservicePermissionsError::InvalidParameterValues(ref cause) => {
write!(f, "{}", cause)
}
ModifySelfservicePermissionsError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ModifySelfservicePermissionsError {}
#[derive(Debug, PartialEq)]
pub enum ModifyWorkspaceAccessPropertiesError {
AccessDenied(String),
ResourceNotFound(String),
}
impl ModifyWorkspaceAccessPropertiesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ModifyWorkspaceAccessPropertiesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
ModifyWorkspaceAccessPropertiesError::AccessDenied(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
ModifyWorkspaceAccessPropertiesError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ModifyWorkspaceAccessPropertiesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifyWorkspaceAccessPropertiesError::AccessDenied(ref cause) => write!(f, "{}", cause),
ModifyWorkspaceAccessPropertiesError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ModifyWorkspaceAccessPropertiesError {}
#[derive(Debug, PartialEq)]
pub enum ModifyWorkspaceCreationPropertiesError {
AccessDenied(String),
InvalidParameterValues(String),
ResourceNotFound(String),
}
impl ModifyWorkspaceCreationPropertiesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ModifyWorkspaceCreationPropertiesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
ModifyWorkspaceCreationPropertiesError::AccessDenied(err.msg),
)
}
"InvalidParameterValuesException" => {
return RusotoError::Service(
ModifyWorkspaceCreationPropertiesError::InvalidParameterValues(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
ModifyWorkspaceCreationPropertiesError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ModifyWorkspaceCreationPropertiesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifyWorkspaceCreationPropertiesError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
ModifyWorkspaceCreationPropertiesError::InvalidParameterValues(ref cause) => {
write!(f, "{}", cause)
}
ModifyWorkspaceCreationPropertiesError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ModifyWorkspaceCreationPropertiesError {}
#[derive(Debug, PartialEq)]
pub enum ModifyWorkspacePropertiesError {
AccessDenied(String),
InvalidParameterValues(String),
InvalidResourceState(String),
OperationInProgress(String),
ResourceNotFound(String),
ResourceUnavailable(String),
UnsupportedWorkspaceConfiguration(String),
}
impl ModifyWorkspacePropertiesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyWorkspacePropertiesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ModifyWorkspacePropertiesError::AccessDenied(
err.msg,
))
}
"InvalidParameterValuesException" => {
return RusotoError::Service(
ModifyWorkspacePropertiesError::InvalidParameterValues(err.msg),
)
}
"InvalidResourceStateException" => {
return RusotoError::Service(
ModifyWorkspacePropertiesError::InvalidResourceState(err.msg),
)
}
"OperationInProgressException" => {
return RusotoError::Service(
ModifyWorkspacePropertiesError::OperationInProgress(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(ModifyWorkspacePropertiesError::ResourceNotFound(
err.msg,
))
}
"ResourceUnavailableException" => {
return RusotoError::Service(
ModifyWorkspacePropertiesError::ResourceUnavailable(err.msg),
)
}
"UnsupportedWorkspaceConfigurationException" => {
return RusotoError::Service(
ModifyWorkspacePropertiesError::UnsupportedWorkspaceConfiguration(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ModifyWorkspacePropertiesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifyWorkspacePropertiesError::AccessDenied(ref cause) => write!(f, "{}", cause),
ModifyWorkspacePropertiesError::InvalidParameterValues(ref cause) => {
write!(f, "{}", cause)
}
ModifyWorkspacePropertiesError::InvalidResourceState(ref cause) => {
write!(f, "{}", cause)
}
ModifyWorkspacePropertiesError::OperationInProgress(ref cause) => {
write!(f, "{}", cause)
}
ModifyWorkspacePropertiesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ModifyWorkspacePropertiesError::ResourceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
ModifyWorkspacePropertiesError::UnsupportedWorkspaceConfiguration(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ModifyWorkspacePropertiesError {}
#[derive(Debug, PartialEq)]
pub enum ModifyWorkspaceStateError {
InvalidParameterValues(String),
InvalidResourceState(String),
ResourceNotFound(String),
}
impl ModifyWorkspaceStateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ModifyWorkspaceStateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParameterValuesException" => {
return RusotoError::Service(ModifyWorkspaceStateError::InvalidParameterValues(
err.msg,
))
}
"InvalidResourceStateException" => {
return RusotoError::Service(ModifyWorkspaceStateError::InvalidResourceState(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ModifyWorkspaceStateError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ModifyWorkspaceStateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ModifyWorkspaceStateError::InvalidParameterValues(ref cause) => write!(f, "{}", cause),
ModifyWorkspaceStateError::InvalidResourceState(ref cause) => write!(f, "{}", cause),
ModifyWorkspaceStateError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ModifyWorkspaceStateError {}
#[derive(Debug, PartialEq)]
pub enum RebootWorkspacesError {}
impl RebootWorkspacesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RebootWorkspacesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RebootWorkspacesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for RebootWorkspacesError {}
#[derive(Debug, PartialEq)]
pub enum RebuildWorkspacesError {}
impl RebuildWorkspacesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RebuildWorkspacesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RebuildWorkspacesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for RebuildWorkspacesError {}
#[derive(Debug, PartialEq)]
pub enum RegisterWorkspaceDirectoryError {
AccessDenied(String),
InvalidParameterValues(String),
InvalidResourceState(String),
OperationNotSupported(String),
ResourceLimitExceeded(String),
ResourceNotFound(String),
UnsupportedNetworkConfiguration(String),
WorkspacesDefaultRoleNotFound(String),
}
impl RegisterWorkspaceDirectoryError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<RegisterWorkspaceDirectoryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(RegisterWorkspaceDirectoryError::AccessDenied(
err.msg,
))
}
"InvalidParameterValuesException" => {
return RusotoError::Service(
RegisterWorkspaceDirectoryError::InvalidParameterValues(err.msg),
)
}
"InvalidResourceStateException" => {
return RusotoError::Service(
RegisterWorkspaceDirectoryError::InvalidResourceState(err.msg),
)
}
"OperationNotSupportedException" => {
return RusotoError::Service(
RegisterWorkspaceDirectoryError::OperationNotSupported(err.msg),
)
}
"ResourceLimitExceededException" => {
return RusotoError::Service(
RegisterWorkspaceDirectoryError::ResourceLimitExceeded(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(RegisterWorkspaceDirectoryError::ResourceNotFound(
err.msg,
))
}
"UnsupportedNetworkConfigurationException" => {
return RusotoError::Service(
RegisterWorkspaceDirectoryError::UnsupportedNetworkConfiguration(err.msg),
)
}
"WorkspacesDefaultRoleNotFoundException" => {
return RusotoError::Service(
RegisterWorkspaceDirectoryError::WorkspacesDefaultRoleNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RegisterWorkspaceDirectoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RegisterWorkspaceDirectoryError::AccessDenied(ref cause) => write!(f, "{}", cause),
RegisterWorkspaceDirectoryError::InvalidParameterValues(ref cause) => {
write!(f, "{}", cause)
}
RegisterWorkspaceDirectoryError::InvalidResourceState(ref cause) => {
write!(f, "{}", cause)
}
RegisterWorkspaceDirectoryError::OperationNotSupported(ref cause) => {
write!(f, "{}", cause)
}
RegisterWorkspaceDirectoryError::ResourceLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
RegisterWorkspaceDirectoryError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
RegisterWorkspaceDirectoryError::UnsupportedNetworkConfiguration(ref cause) => {
write!(f, "{}", cause)
}
RegisterWorkspaceDirectoryError::WorkspacesDefaultRoleNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for RegisterWorkspaceDirectoryError {}
#[derive(Debug, PartialEq)]
pub enum RestoreWorkspaceError {
AccessDenied(String),
InvalidParameterValues(String),
ResourceNotFound(String),
}
impl RestoreWorkspaceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RestoreWorkspaceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(RestoreWorkspaceError::AccessDenied(err.msg))
}
"InvalidParameterValuesException" => {
return RusotoError::Service(RestoreWorkspaceError::InvalidParameterValues(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(RestoreWorkspaceError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RestoreWorkspaceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RestoreWorkspaceError::AccessDenied(ref cause) => write!(f, "{}", cause),
RestoreWorkspaceError::InvalidParameterValues(ref cause) => write!(f, "{}", cause),
RestoreWorkspaceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RestoreWorkspaceError {}
#[derive(Debug, PartialEq)]
pub enum RevokeIpRulesError {
AccessDenied(String),
InvalidParameterValues(String),
InvalidResourceState(String),
ResourceNotFound(String),
}
impl RevokeIpRulesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RevokeIpRulesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(RevokeIpRulesError::AccessDenied(err.msg))
}
"InvalidParameterValuesException" => {
return RusotoError::Service(RevokeIpRulesError::InvalidParameterValues(
err.msg,
))
}
"InvalidResourceStateException" => {
return RusotoError::Service(RevokeIpRulesError::InvalidResourceState(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(RevokeIpRulesError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RevokeIpRulesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RevokeIpRulesError::AccessDenied(ref cause) => write!(f, "{}", cause),
RevokeIpRulesError::InvalidParameterValues(ref cause) => write!(f, "{}", cause),
RevokeIpRulesError::InvalidResourceState(ref cause) => write!(f, "{}", cause),
RevokeIpRulesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RevokeIpRulesError {}
#[derive(Debug, PartialEq)]
pub enum StartWorkspacesError {}
impl StartWorkspacesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartWorkspacesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartWorkspacesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for StartWorkspacesError {}
#[derive(Debug, PartialEq)]
pub enum StopWorkspacesError {}
impl StopWorkspacesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopWorkspacesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StopWorkspacesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for StopWorkspacesError {}
#[derive(Debug, PartialEq)]
pub enum TerminateWorkspacesError {}
impl TerminateWorkspacesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TerminateWorkspacesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TerminateWorkspacesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for TerminateWorkspacesError {}
#[derive(Debug, PartialEq)]
pub enum UpdateRulesOfIpGroupError {
AccessDenied(String),
InvalidParameterValues(String),
InvalidResourceState(String),
ResourceLimitExceeded(String),
ResourceNotFound(String),
}
impl UpdateRulesOfIpGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateRulesOfIpGroupError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(UpdateRulesOfIpGroupError::AccessDenied(err.msg))
}
"InvalidParameterValuesException" => {
return RusotoError::Service(UpdateRulesOfIpGroupError::InvalidParameterValues(
err.msg,
))
}
"InvalidResourceStateException" => {
return RusotoError::Service(UpdateRulesOfIpGroupError::InvalidResourceState(
err.msg,
))
}
"ResourceLimitExceededException" => {
return RusotoError::Service(UpdateRulesOfIpGroupError::ResourceLimitExceeded(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateRulesOfIpGroupError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateRulesOfIpGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateRulesOfIpGroupError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpdateRulesOfIpGroupError::InvalidParameterValues(ref cause) => write!(f, "{}", cause),
UpdateRulesOfIpGroupError::InvalidResourceState(ref cause) => write!(f, "{}", cause),
UpdateRulesOfIpGroupError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateRulesOfIpGroupError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateRulesOfIpGroupError {}
#[async_trait]
pub trait Workspaces {
async fn associate_ip_groups(
&self,
input: AssociateIpGroupsRequest,
) -> Result<AssociateIpGroupsResult, RusotoError<AssociateIpGroupsError>>;
async fn authorize_ip_rules(
&self,
input: AuthorizeIpRulesRequest,
) -> Result<AuthorizeIpRulesResult, RusotoError<AuthorizeIpRulesError>>;
async fn copy_workspace_image(
&self,
input: CopyWorkspaceImageRequest,
) -> Result<CopyWorkspaceImageResult, RusotoError<CopyWorkspaceImageError>>;
async fn create_ip_group(
&self,
input: CreateIpGroupRequest,
) -> Result<CreateIpGroupResult, RusotoError<CreateIpGroupError>>;
async fn create_tags(
&self,
input: CreateTagsRequest,
) -> Result<CreateTagsResult, RusotoError<CreateTagsError>>;
async fn create_workspaces(
&self,
input: CreateWorkspacesRequest,
) -> Result<CreateWorkspacesResult, RusotoError<CreateWorkspacesError>>;
async fn delete_ip_group(
&self,
input: DeleteIpGroupRequest,
) -> Result<DeleteIpGroupResult, RusotoError<DeleteIpGroupError>>;
async fn delete_tags(
&self,
input: DeleteTagsRequest,
) -> Result<DeleteTagsResult, RusotoError<DeleteTagsError>>;
async fn delete_workspace_image(
&self,
input: DeleteWorkspaceImageRequest,
) -> Result<DeleteWorkspaceImageResult, RusotoError<DeleteWorkspaceImageError>>;
async fn deregister_workspace_directory(
&self,
input: DeregisterWorkspaceDirectoryRequest,
) -> Result<DeregisterWorkspaceDirectoryResult, RusotoError<DeregisterWorkspaceDirectoryError>>;
async fn describe_account(
&self,
) -> Result<DescribeAccountResult, RusotoError<DescribeAccountError>>;
async fn describe_account_modifications(
&self,
input: DescribeAccountModificationsRequest,
) -> Result<DescribeAccountModificationsResult, RusotoError<DescribeAccountModificationsError>>;
async fn describe_client_properties(
&self,
input: DescribeClientPropertiesRequest,
) -> Result<DescribeClientPropertiesResult, RusotoError<DescribeClientPropertiesError>>;
async fn describe_ip_groups(
&self,
input: DescribeIpGroupsRequest,
) -> Result<DescribeIpGroupsResult, RusotoError<DescribeIpGroupsError>>;
async fn describe_tags(
&self,
input: DescribeTagsRequest,
) -> Result<DescribeTagsResult, RusotoError<DescribeTagsError>>;
async fn describe_workspace_bundles(
&self,
input: DescribeWorkspaceBundlesRequest,
) -> Result<DescribeWorkspaceBundlesResult, RusotoError<DescribeWorkspaceBundlesError>>;
async fn describe_workspace_directories(
&self,
input: DescribeWorkspaceDirectoriesRequest,
) -> Result<DescribeWorkspaceDirectoriesResult, RusotoError<DescribeWorkspaceDirectoriesError>>;
async fn describe_workspace_images(
&self,
input: DescribeWorkspaceImagesRequest,
) -> Result<DescribeWorkspaceImagesResult, RusotoError<DescribeWorkspaceImagesError>>;
async fn describe_workspace_snapshots(
&self,
input: DescribeWorkspaceSnapshotsRequest,
) -> Result<DescribeWorkspaceSnapshotsResult, RusotoError<DescribeWorkspaceSnapshotsError>>;
async fn describe_workspaces(
&self,
input: DescribeWorkspacesRequest,
) -> Result<DescribeWorkspacesResult, RusotoError<DescribeWorkspacesError>>;
async fn describe_workspaces_connection_status(
&self,
input: DescribeWorkspacesConnectionStatusRequest,
) -> Result<
DescribeWorkspacesConnectionStatusResult,
RusotoError<DescribeWorkspacesConnectionStatusError>,
>;
async fn disassociate_ip_groups(
&self,
input: DisassociateIpGroupsRequest,
) -> Result<DisassociateIpGroupsResult, RusotoError<DisassociateIpGroupsError>>;
async fn import_workspace_image(
&self,
input: ImportWorkspaceImageRequest,
) -> Result<ImportWorkspaceImageResult, RusotoError<ImportWorkspaceImageError>>;
async fn list_available_management_cidr_ranges(
&self,
input: ListAvailableManagementCidrRangesRequest,
) -> Result<
ListAvailableManagementCidrRangesResult,
RusotoError<ListAvailableManagementCidrRangesError>,
>;
async fn migrate_workspace(
&self,
input: MigrateWorkspaceRequest,
) -> Result<MigrateWorkspaceResult, RusotoError<MigrateWorkspaceError>>;
async fn modify_account(
&self,
input: ModifyAccountRequest,
) -> Result<ModifyAccountResult, RusotoError<ModifyAccountError>>;
async fn modify_client_properties(
&self,
input: ModifyClientPropertiesRequest,
) -> Result<ModifyClientPropertiesResult, RusotoError<ModifyClientPropertiesError>>;
async fn modify_selfservice_permissions(
&self,
input: ModifySelfservicePermissionsRequest,
) -> Result<ModifySelfservicePermissionsResult, RusotoError<ModifySelfservicePermissionsError>>;
async fn modify_workspace_access_properties(
&self,
input: ModifyWorkspaceAccessPropertiesRequest,
) -> Result<
ModifyWorkspaceAccessPropertiesResult,
RusotoError<ModifyWorkspaceAccessPropertiesError>,
>;
async fn modify_workspace_creation_properties(
&self,
input: ModifyWorkspaceCreationPropertiesRequest,
) -> Result<
ModifyWorkspaceCreationPropertiesResult,
RusotoError<ModifyWorkspaceCreationPropertiesError>,
>;
async fn modify_workspace_properties(
&self,
input: ModifyWorkspacePropertiesRequest,
) -> Result<ModifyWorkspacePropertiesResult, RusotoError<ModifyWorkspacePropertiesError>>;
async fn modify_workspace_state(
&self,
input: ModifyWorkspaceStateRequest,
) -> Result<ModifyWorkspaceStateResult, RusotoError<ModifyWorkspaceStateError>>;
async fn reboot_workspaces(
&self,
input: RebootWorkspacesRequest,
) -> Result<RebootWorkspacesResult, RusotoError<RebootWorkspacesError>>;
async fn rebuild_workspaces(
&self,
input: RebuildWorkspacesRequest,
) -> Result<RebuildWorkspacesResult, RusotoError<RebuildWorkspacesError>>;
async fn register_workspace_directory(
&self,
input: RegisterWorkspaceDirectoryRequest,
) -> Result<RegisterWorkspaceDirectoryResult, RusotoError<RegisterWorkspaceDirectoryError>>;
async fn restore_workspace(
&self,
input: RestoreWorkspaceRequest,
) -> Result<RestoreWorkspaceResult, RusotoError<RestoreWorkspaceError>>;
async fn revoke_ip_rules(
&self,
input: RevokeIpRulesRequest,
) -> Result<RevokeIpRulesResult, RusotoError<RevokeIpRulesError>>;
async fn start_workspaces(
&self,
input: StartWorkspacesRequest,
) -> Result<StartWorkspacesResult, RusotoError<StartWorkspacesError>>;
async fn stop_workspaces(
&self,
input: StopWorkspacesRequest,
) -> Result<StopWorkspacesResult, RusotoError<StopWorkspacesError>>;
async fn terminate_workspaces(
&self,
input: TerminateWorkspacesRequest,
) -> Result<TerminateWorkspacesResult, RusotoError<TerminateWorkspacesError>>;
async fn update_rules_of_ip_group(
&self,
input: UpdateRulesOfIpGroupRequest,
) -> Result<UpdateRulesOfIpGroupResult, RusotoError<UpdateRulesOfIpGroupError>>;
}
#[derive(Clone)]
pub struct WorkspacesClient {
client: Client,
region: region::Region,
}
impl WorkspacesClient {
pub fn new(region: region::Region) -> WorkspacesClient {
WorkspacesClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> WorkspacesClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
WorkspacesClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> WorkspacesClient {
WorkspacesClient { client, region }
}
}
#[async_trait]
impl Workspaces for WorkspacesClient {
async fn associate_ip_groups(
&self,
input: AssociateIpGroupsRequest,
) -> Result<AssociateIpGroupsResult, RusotoError<AssociateIpGroupsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.AssociateIpGroups");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AssociateIpGroupsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<AssociateIpGroupsResult, _>()
}
async fn authorize_ip_rules(
&self,
input: AuthorizeIpRulesRequest,
) -> Result<AuthorizeIpRulesResult, RusotoError<AuthorizeIpRulesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.AuthorizeIpRules");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AuthorizeIpRulesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<AuthorizeIpRulesResult, _>()
}
async fn copy_workspace_image(
&self,
input: CopyWorkspaceImageRequest,
) -> Result<CopyWorkspaceImageResult, RusotoError<CopyWorkspaceImageError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.CopyWorkspaceImage");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CopyWorkspaceImageError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CopyWorkspaceImageResult, _>()
}
async fn create_ip_group(
&self,
input: CreateIpGroupRequest,
) -> Result<CreateIpGroupResult, RusotoError<CreateIpGroupError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.CreateIpGroup");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateIpGroupError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateIpGroupResult, _>()
}
async fn create_tags(
&self,
input: CreateTagsRequest,
) -> Result<CreateTagsResult, RusotoError<CreateTagsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.CreateTags");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateTagsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateTagsResult, _>()
}
async fn create_workspaces(
&self,
input: CreateWorkspacesRequest,
) -> Result<CreateWorkspacesResult, RusotoError<CreateWorkspacesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.CreateWorkspaces");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateWorkspacesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateWorkspacesResult, _>()
}
async fn delete_ip_group(
&self,
input: DeleteIpGroupRequest,
) -> Result<DeleteIpGroupResult, RusotoError<DeleteIpGroupError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.DeleteIpGroup");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteIpGroupError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteIpGroupResult, _>()
}
async fn delete_tags(
&self,
input: DeleteTagsRequest,
) -> Result<DeleteTagsResult, RusotoError<DeleteTagsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.DeleteTags");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteTagsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteTagsResult, _>()
}
async fn delete_workspace_image(
&self,
input: DeleteWorkspaceImageRequest,
) -> Result<DeleteWorkspaceImageResult, RusotoError<DeleteWorkspaceImageError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.DeleteWorkspaceImage");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteWorkspaceImageError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteWorkspaceImageResult, _>()
}
async fn deregister_workspace_directory(
&self,
input: DeregisterWorkspaceDirectoryRequest,
) -> Result<DeregisterWorkspaceDirectoryResult, RusotoError<DeregisterWorkspaceDirectoryError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"WorkspacesService.DeregisterWorkspaceDirectory",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeregisterWorkspaceDirectoryError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeregisterWorkspaceDirectoryResult, _>()
}
async fn describe_account(
&self,
) -> Result<DescribeAccountResult, RusotoError<DescribeAccountError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.DescribeAccount");
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(request, DescribeAccountError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeAccountResult, _>()
}
async fn describe_account_modifications(
&self,
input: DescribeAccountModificationsRequest,
) -> Result<DescribeAccountModificationsResult, RusotoError<DescribeAccountModificationsError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"WorkspacesService.DescribeAccountModifications",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeAccountModificationsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeAccountModificationsResult, _>()
}
async fn describe_client_properties(
&self,
input: DescribeClientPropertiesRequest,
) -> Result<DescribeClientPropertiesResult, RusotoError<DescribeClientPropertiesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.DescribeClientProperties");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeClientPropertiesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeClientPropertiesResult, _>()
}
async fn describe_ip_groups(
&self,
input: DescribeIpGroupsRequest,
) -> Result<DescribeIpGroupsResult, RusotoError<DescribeIpGroupsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.DescribeIpGroups");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeIpGroupsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeIpGroupsResult, _>()
}
async fn describe_tags(
&self,
input: DescribeTagsRequest,
) -> Result<DescribeTagsResult, RusotoError<DescribeTagsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.DescribeTags");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeTagsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeTagsResult, _>()
}
async fn describe_workspace_bundles(
&self,
input: DescribeWorkspaceBundlesRequest,
) -> Result<DescribeWorkspaceBundlesResult, RusotoError<DescribeWorkspaceBundlesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.DescribeWorkspaceBundles");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeWorkspaceBundlesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeWorkspaceBundlesResult, _>()
}
async fn describe_workspace_directories(
&self,
input: DescribeWorkspaceDirectoriesRequest,
) -> Result<DescribeWorkspaceDirectoriesResult, RusotoError<DescribeWorkspaceDirectoriesError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"WorkspacesService.DescribeWorkspaceDirectories",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeWorkspaceDirectoriesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeWorkspaceDirectoriesResult, _>()
}
async fn describe_workspace_images(
&self,
input: DescribeWorkspaceImagesRequest,
) -> Result<DescribeWorkspaceImagesResult, RusotoError<DescribeWorkspaceImagesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.DescribeWorkspaceImages");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeWorkspaceImagesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeWorkspaceImagesResult, _>()
}
async fn describe_workspace_snapshots(
&self,
input: DescribeWorkspaceSnapshotsRequest,
) -> Result<DescribeWorkspaceSnapshotsResult, RusotoError<DescribeWorkspaceSnapshotsError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"WorkspacesService.DescribeWorkspaceSnapshots",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeWorkspaceSnapshotsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeWorkspaceSnapshotsResult, _>()
}
async fn describe_workspaces(
&self,
input: DescribeWorkspacesRequest,
) -> Result<DescribeWorkspacesResult, RusotoError<DescribeWorkspacesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.DescribeWorkspaces");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeWorkspacesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeWorkspacesResult, _>()
}
async fn describe_workspaces_connection_status(
&self,
input: DescribeWorkspacesConnectionStatusRequest,
) -> Result<
DescribeWorkspacesConnectionStatusResult,
RusotoError<DescribeWorkspacesConnectionStatusError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"WorkspacesService.DescribeWorkspacesConnectionStatus",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DescribeWorkspacesConnectionStatusError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeWorkspacesConnectionStatusResult, _>()
}
async fn disassociate_ip_groups(
&self,
input: DisassociateIpGroupsRequest,
) -> Result<DisassociateIpGroupsResult, RusotoError<DisassociateIpGroupsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.DisassociateIpGroups");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DisassociateIpGroupsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DisassociateIpGroupsResult, _>()
}
async fn import_workspace_image(
&self,
input: ImportWorkspaceImageRequest,
) -> Result<ImportWorkspaceImageResult, RusotoError<ImportWorkspaceImageError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.ImportWorkspaceImage");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ImportWorkspaceImageError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ImportWorkspaceImageResult, _>()
}
async fn list_available_management_cidr_ranges(
&self,
input: ListAvailableManagementCidrRangesRequest,
) -> Result<
ListAvailableManagementCidrRangesResult,
RusotoError<ListAvailableManagementCidrRangesError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"WorkspacesService.ListAvailableManagementCidrRanges",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
ListAvailableManagementCidrRangesError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListAvailableManagementCidrRangesResult, _>()
}
async fn migrate_workspace(
&self,
input: MigrateWorkspaceRequest,
) -> Result<MigrateWorkspaceResult, RusotoError<MigrateWorkspaceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.MigrateWorkspace");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, MigrateWorkspaceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<MigrateWorkspaceResult, _>()
}
async fn modify_account(
&self,
input: ModifyAccountRequest,
) -> Result<ModifyAccountResult, RusotoError<ModifyAccountError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.ModifyAccount");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ModifyAccountError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ModifyAccountResult, _>()
}
async fn modify_client_properties(
&self,
input: ModifyClientPropertiesRequest,
) -> Result<ModifyClientPropertiesResult, RusotoError<ModifyClientPropertiesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.ModifyClientProperties");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ModifyClientPropertiesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ModifyClientPropertiesResult, _>()
}
async fn modify_selfservice_permissions(
&self,
input: ModifySelfservicePermissionsRequest,
) -> Result<ModifySelfservicePermissionsResult, RusotoError<ModifySelfservicePermissionsError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"WorkspacesService.ModifySelfservicePermissions",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ModifySelfservicePermissionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ModifySelfservicePermissionsResult, _>()
}
async fn modify_workspace_access_properties(
&self,
input: ModifyWorkspaceAccessPropertiesRequest,
) -> Result<
ModifyWorkspaceAccessPropertiesResult,
RusotoError<ModifyWorkspaceAccessPropertiesError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"WorkspacesService.ModifyWorkspaceAccessProperties",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ModifyWorkspaceAccessPropertiesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ModifyWorkspaceAccessPropertiesResult, _>()
}
async fn modify_workspace_creation_properties(
&self,
input: ModifyWorkspaceCreationPropertiesRequest,
) -> Result<
ModifyWorkspaceCreationPropertiesResult,
RusotoError<ModifyWorkspaceCreationPropertiesError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"WorkspacesService.ModifyWorkspaceCreationProperties",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
ModifyWorkspaceCreationPropertiesError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ModifyWorkspaceCreationPropertiesResult, _>()
}
async fn modify_workspace_properties(
&self,
input: ModifyWorkspacePropertiesRequest,
) -> Result<ModifyWorkspacePropertiesResult, RusotoError<ModifyWorkspacePropertiesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"WorkspacesService.ModifyWorkspaceProperties",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ModifyWorkspacePropertiesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ModifyWorkspacePropertiesResult, _>()
}
async fn modify_workspace_state(
&self,
input: ModifyWorkspaceStateRequest,
) -> Result<ModifyWorkspaceStateResult, RusotoError<ModifyWorkspaceStateError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.ModifyWorkspaceState");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ModifyWorkspaceStateError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ModifyWorkspaceStateResult, _>()
}
async fn reboot_workspaces(
&self,
input: RebootWorkspacesRequest,
) -> Result<RebootWorkspacesResult, RusotoError<RebootWorkspacesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.RebootWorkspaces");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, RebootWorkspacesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<RebootWorkspacesResult, _>()
}
async fn rebuild_workspaces(
&self,
input: RebuildWorkspacesRequest,
) -> Result<RebuildWorkspacesResult, RusotoError<RebuildWorkspacesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.RebuildWorkspaces");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, RebuildWorkspacesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<RebuildWorkspacesResult, _>()
}
async fn register_workspace_directory(
&self,
input: RegisterWorkspaceDirectoryRequest,
) -> Result<RegisterWorkspaceDirectoryResult, RusotoError<RegisterWorkspaceDirectoryError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"WorkspacesService.RegisterWorkspaceDirectory",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, RegisterWorkspaceDirectoryError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<RegisterWorkspaceDirectoryResult, _>()
}
async fn restore_workspace(
&self,
input: RestoreWorkspaceRequest,
) -> Result<RestoreWorkspaceResult, RusotoError<RestoreWorkspaceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.RestoreWorkspace");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, RestoreWorkspaceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<RestoreWorkspaceResult, _>()
}
async fn revoke_ip_rules(
&self,
input: RevokeIpRulesRequest,
) -> Result<RevokeIpRulesResult, RusotoError<RevokeIpRulesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.RevokeIpRules");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, RevokeIpRulesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<RevokeIpRulesResult, _>()
}
async fn start_workspaces(
&self,
input: StartWorkspacesRequest,
) -> Result<StartWorkspacesResult, RusotoError<StartWorkspacesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.StartWorkspaces");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StartWorkspacesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<StartWorkspacesResult, _>()
}
async fn stop_workspaces(
&self,
input: StopWorkspacesRequest,
) -> Result<StopWorkspacesResult, RusotoError<StopWorkspacesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.StopWorkspaces");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StopWorkspacesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<StopWorkspacesResult, _>()
}
async fn terminate_workspaces(
&self,
input: TerminateWorkspacesRequest,
) -> Result<TerminateWorkspacesResult, RusotoError<TerminateWorkspacesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.TerminateWorkspaces");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, TerminateWorkspacesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<TerminateWorkspacesResult, _>()
}
async fn update_rules_of_ip_group(
&self,
input: UpdateRulesOfIpGroupRequest,
) -> Result<UpdateRulesOfIpGroupResult, RusotoError<UpdateRulesOfIpGroupError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "WorkspacesService.UpdateRulesOfIpGroup");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateRulesOfIpGroupError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateRulesOfIpGroupResult, _>()
}
}