use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::param::{Params, ServiceParams};
use rusoto_core::proto;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
use serde_json;
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchDeleteWorldsRequest {
#[serde(rename = "worlds")]
pub worlds: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchDeleteWorldsResponse {
#[serde(rename = "unprocessedWorlds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unprocessed_worlds: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchDescribeSimulationJobRequest {
#[serde(rename = "jobs")]
pub jobs: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchDescribeSimulationJobResponse {
#[serde(rename = "jobs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub jobs: Option<Vec<SimulationJob>>,
#[serde(rename = "unprocessedJobs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unprocessed_jobs: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct BatchPolicy {
#[serde(rename = "maxConcurrency")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_concurrency: Option<i64>,
#[serde(rename = "timeoutInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timeout_in_seconds: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CancelDeploymentJobRequest {
#[serde(rename = "job")]
pub job: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CancelDeploymentJobResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CancelSimulationJobBatchRequest {
#[serde(rename = "batch")]
pub batch: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CancelSimulationJobBatchResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CancelSimulationJobRequest {
#[serde(rename = "job")]
pub job: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CancelSimulationJobResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CancelWorldExportJobRequest {
#[serde(rename = "job")]
pub job: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CancelWorldExportJobResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CancelWorldGenerationJobRequest {
#[serde(rename = "job")]
pub job: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CancelWorldGenerationJobResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Compute {
#[serde(rename = "simulationUnitLimit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub simulation_unit_limit: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ComputeResponse {
#[serde(rename = "simulationUnitLimit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub simulation_unit_limit: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDeploymentJobRequest {
#[serde(rename = "clientRequestToken")]
pub client_request_token: String,
#[serde(rename = "deploymentApplicationConfigs")]
pub deployment_application_configs: Vec<DeploymentApplicationConfig>,
#[serde(rename = "deploymentConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_config: Option<DeploymentConfig>,
#[serde(rename = "fleet")]
pub fleet: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDeploymentJobResponse {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "deploymentApplicationConfigs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_application_configs: Option<Vec<DeploymentApplicationConfig>>,
#[serde(rename = "deploymentConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_config: Option<DeploymentConfig>,
#[serde(rename = "failureCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_code: Option<String>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "fleet")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fleet: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateFleetRequest {
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateFleetResponse {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateRobotApplicationRequest {
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "robotSoftwareSuite")]
pub robot_software_suite: RobotSoftwareSuite,
#[serde(rename = "sources")]
pub sources: Vec<SourceConfig>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateRobotApplicationResponse {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "lastUpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_at: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "revisionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_id: Option<String>,
#[serde(rename = "robotSoftwareSuite")]
#[serde(skip_serializing_if = "Option::is_none")]
pub robot_software_suite: Option<RobotSoftwareSuite>,
#[serde(rename = "sources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sources: Option<Vec<Source>>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateRobotApplicationVersionRequest {
#[serde(rename = "application")]
pub application: String,
#[serde(rename = "currentRevisionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub current_revision_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateRobotApplicationVersionResponse {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "lastUpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_at: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "revisionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_id: Option<String>,
#[serde(rename = "robotSoftwareSuite")]
#[serde(skip_serializing_if = "Option::is_none")]
pub robot_software_suite: Option<RobotSoftwareSuite>,
#[serde(rename = "sources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sources: Option<Vec<Source>>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateRobotRequest {
#[serde(rename = "architecture")]
pub architecture: String,
#[serde(rename = "greengrassGroupId")]
pub greengrass_group_id: String,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateRobotResponse {
#[serde(rename = "architecture")]
#[serde(skip_serializing_if = "Option::is_none")]
pub architecture: Option<String>,
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "greengrassGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub greengrass_group_id: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateSimulationApplicationRequest {
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "renderingEngine")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rendering_engine: Option<RenderingEngine>,
#[serde(rename = "robotSoftwareSuite")]
pub robot_software_suite: RobotSoftwareSuite,
#[serde(rename = "simulationSoftwareSuite")]
pub simulation_software_suite: SimulationSoftwareSuite,
#[serde(rename = "sources")]
pub sources: Vec<SourceConfig>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateSimulationApplicationResponse {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "lastUpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_at: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "renderingEngine")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rendering_engine: Option<RenderingEngine>,
#[serde(rename = "revisionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_id: Option<String>,
#[serde(rename = "robotSoftwareSuite")]
#[serde(skip_serializing_if = "Option::is_none")]
pub robot_software_suite: Option<RobotSoftwareSuite>,
#[serde(rename = "simulationSoftwareSuite")]
#[serde(skip_serializing_if = "Option::is_none")]
pub simulation_software_suite: Option<SimulationSoftwareSuite>,
#[serde(rename = "sources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sources: Option<Vec<Source>>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateSimulationApplicationVersionRequest {
#[serde(rename = "application")]
pub application: String,
#[serde(rename = "currentRevisionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub current_revision_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateSimulationApplicationVersionResponse {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "lastUpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_at: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "renderingEngine")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rendering_engine: Option<RenderingEngine>,
#[serde(rename = "revisionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_id: Option<String>,
#[serde(rename = "robotSoftwareSuite")]
#[serde(skip_serializing_if = "Option::is_none")]
pub robot_software_suite: Option<RobotSoftwareSuite>,
#[serde(rename = "simulationSoftwareSuite")]
#[serde(skip_serializing_if = "Option::is_none")]
pub simulation_software_suite: Option<SimulationSoftwareSuite>,
#[serde(rename = "sources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sources: Option<Vec<Source>>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateSimulationJobRequest {
#[serde(rename = "clientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "compute")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compute: Option<Compute>,
#[serde(rename = "dataSources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_sources: Option<Vec<DataSourceConfig>>,
#[serde(rename = "failureBehavior")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_behavior: Option<String>,
#[serde(rename = "iamRole")]
pub iam_role: String,
#[serde(rename = "loggingConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub logging_config: Option<LoggingConfig>,
#[serde(rename = "maxJobDurationInSeconds")]
pub max_job_duration_in_seconds: i64,
#[serde(rename = "outputLocation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_location: Option<OutputLocation>,
#[serde(rename = "robotApplications")]
#[serde(skip_serializing_if = "Option::is_none")]
pub robot_applications: Option<Vec<RobotApplicationConfig>>,
#[serde(rename = "simulationApplications")]
#[serde(skip_serializing_if = "Option::is_none")]
pub simulation_applications: Option<Vec<SimulationApplicationConfig>>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "vpcConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_config: Option<VPCConfig>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateSimulationJobResponse {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "clientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "compute")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compute: Option<ComputeResponse>,
#[serde(rename = "dataSources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_sources: Option<Vec<DataSource>>,
#[serde(rename = "failureBehavior")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_behavior: Option<String>,
#[serde(rename = "failureCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_code: Option<String>,
#[serde(rename = "iamRole")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_role: Option<String>,
#[serde(rename = "lastStartedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_started_at: Option<f64>,
#[serde(rename = "lastUpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_at: Option<f64>,
#[serde(rename = "loggingConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub logging_config: Option<LoggingConfig>,
#[serde(rename = "maxJobDurationInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_job_duration_in_seconds: Option<i64>,
#[serde(rename = "outputLocation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_location: Option<OutputLocation>,
#[serde(rename = "robotApplications")]
#[serde(skip_serializing_if = "Option::is_none")]
pub robot_applications: Option<Vec<RobotApplicationConfig>>,
#[serde(rename = "simulationApplications")]
#[serde(skip_serializing_if = "Option::is_none")]
pub simulation_applications: Option<Vec<SimulationApplicationConfig>>,
#[serde(rename = "simulationTimeMillis")]
#[serde(skip_serializing_if = "Option::is_none")]
pub simulation_time_millis: Option<i64>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "vpcConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_config: Option<VPCConfigResponse>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateWorldExportJobRequest {
#[serde(rename = "clientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "iamRole")]
pub iam_role: String,
#[serde(rename = "outputLocation")]
pub output_location: OutputLocation,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "worlds")]
pub worlds: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateWorldExportJobResponse {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "clientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "failureCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_code: Option<String>,
#[serde(rename = "iamRole")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_role: Option<String>,
#[serde(rename = "outputLocation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_location: Option<OutputLocation>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateWorldGenerationJobRequest {
#[serde(rename = "clientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "template")]
pub template: String,
#[serde(rename = "worldCount")]
pub world_count: WorldCount,
#[serde(rename = "worldTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub world_tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateWorldGenerationJobResponse {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "clientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "failureCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_code: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "template")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template: Option<String>,
#[serde(rename = "worldCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub world_count: Option<WorldCount>,
#[serde(rename = "worldTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub world_tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateWorldTemplateRequest {
#[serde(rename = "clientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "templateBody")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_body: Option<String>,
#[serde(rename = "templateLocation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_location: Option<TemplateLocation>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateWorldTemplateResponse {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "clientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DataSource {
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "s3Bucket")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s_3_bucket: Option<String>,
#[serde(rename = "s3Keys")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s_3_keys: Option<Vec<S3KeyOutput>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DataSourceConfig {
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "s3Bucket")]
pub s_3_bucket: String,
#[serde(rename = "s3Keys")]
pub s_3_keys: Vec<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteFleetRequest {
#[serde(rename = "fleet")]
pub fleet: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteFleetResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteRobotApplicationRequest {
#[serde(rename = "application")]
pub application: String,
#[serde(rename = "applicationVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteRobotApplicationResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteRobotRequest {
#[serde(rename = "robot")]
pub robot: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteRobotResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteSimulationApplicationRequest {
#[serde(rename = "application")]
pub application: String,
#[serde(rename = "applicationVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteSimulationApplicationResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteWorldTemplateRequest {
#[serde(rename = "template")]
pub template: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteWorldTemplateResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DeploymentApplicationConfig {
#[serde(rename = "application")]
pub application: String,
#[serde(rename = "applicationVersion")]
pub application_version: String,
#[serde(rename = "launchConfig")]
pub launch_config: DeploymentLaunchConfig,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DeploymentConfig {
#[serde(rename = "concurrentDeploymentPercentage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub concurrent_deployment_percentage: Option<i64>,
#[serde(rename = "downloadConditionFile")]
#[serde(skip_serializing_if = "Option::is_none")]
pub download_condition_file: Option<S3Object>,
#[serde(rename = "failureThresholdPercentage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_threshold_percentage: Option<i64>,
#[serde(rename = "robotDeploymentTimeoutInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub robot_deployment_timeout_in_seconds: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeploymentJob {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "deploymentApplicationConfigs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_application_configs: Option<Vec<DeploymentApplicationConfig>>,
#[serde(rename = "deploymentConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_config: Option<DeploymentConfig>,
#[serde(rename = "failureCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_code: Option<String>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "fleet")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fleet: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DeploymentLaunchConfig {
#[serde(rename = "environmentVariables")]
#[serde(skip_serializing_if = "Option::is_none")]
pub environment_variables: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "launchFile")]
pub launch_file: String,
#[serde(rename = "packageName")]
pub package_name: String,
#[serde(rename = "postLaunchFile")]
#[serde(skip_serializing_if = "Option::is_none")]
pub post_launch_file: Option<String>,
#[serde(rename = "preLaunchFile")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pre_launch_file: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeregisterRobotRequest {
#[serde(rename = "fleet")]
pub fleet: String,
#[serde(rename = "robot")]
pub robot: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeregisterRobotResponse {
#[serde(rename = "fleet")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fleet: Option<String>,
#[serde(rename = "robot")]
#[serde(skip_serializing_if = "Option::is_none")]
pub robot: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeDeploymentJobRequest {
#[serde(rename = "job")]
pub job: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeDeploymentJobResponse {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "deploymentApplicationConfigs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_application_configs: Option<Vec<DeploymentApplicationConfig>>,
#[serde(rename = "deploymentConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_config: Option<DeploymentConfig>,
#[serde(rename = "failureCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_code: Option<String>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "fleet")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fleet: Option<String>,
#[serde(rename = "robotDeploymentSummary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub robot_deployment_summary: Option<Vec<RobotDeployment>>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeFleetRequest {
#[serde(rename = "fleet")]
pub fleet: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeFleetResponse {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "lastDeploymentJob")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_deployment_job: Option<String>,
#[serde(rename = "lastDeploymentStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_deployment_status: Option<String>,
#[serde(rename = "lastDeploymentTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_deployment_time: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "robots")]
#[serde(skip_serializing_if = "Option::is_none")]
pub robots: Option<Vec<Robot>>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeRobotApplicationRequest {
#[serde(rename = "application")]
pub application: String,
#[serde(rename = "applicationVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeRobotApplicationResponse {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "lastUpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_at: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "revisionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_id: Option<String>,
#[serde(rename = "robotSoftwareSuite")]
#[serde(skip_serializing_if = "Option::is_none")]
pub robot_software_suite: Option<RobotSoftwareSuite>,
#[serde(rename = "sources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sources: Option<Vec<Source>>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeRobotRequest {
#[serde(rename = "robot")]
pub robot: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeRobotResponse {
#[serde(rename = "architecture")]
#[serde(skip_serializing_if = "Option::is_none")]
pub architecture: Option<String>,
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "fleetArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fleet_arn: Option<String>,
#[serde(rename = "greengrassGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub greengrass_group_id: Option<String>,
#[serde(rename = "lastDeploymentJob")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_deployment_job: Option<String>,
#[serde(rename = "lastDeploymentTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_deployment_time: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeSimulationApplicationRequest {
#[serde(rename = "application")]
pub application: String,
#[serde(rename = "applicationVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeSimulationApplicationResponse {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "lastUpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_at: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "renderingEngine")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rendering_engine: Option<RenderingEngine>,
#[serde(rename = "revisionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_id: Option<String>,
#[serde(rename = "robotSoftwareSuite")]
#[serde(skip_serializing_if = "Option::is_none")]
pub robot_software_suite: Option<RobotSoftwareSuite>,
#[serde(rename = "simulationSoftwareSuite")]
#[serde(skip_serializing_if = "Option::is_none")]
pub simulation_software_suite: Option<SimulationSoftwareSuite>,
#[serde(rename = "sources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sources: Option<Vec<Source>>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeSimulationJobBatchRequest {
#[serde(rename = "batch")]
pub batch: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeSimulationJobBatchResponse {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "batchPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub batch_policy: Option<BatchPolicy>,
#[serde(rename = "clientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "createdRequests")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_requests: Option<Vec<SimulationJobSummary>>,
#[serde(rename = "failedRequests")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed_requests: Option<Vec<FailedCreateSimulationJobRequest>>,
#[serde(rename = "failureCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_code: Option<String>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "lastUpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_at: Option<f64>,
#[serde(rename = "pendingRequests")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pending_requests: Option<Vec<SimulationJobRequest>>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeSimulationJobRequest {
#[serde(rename = "job")]
pub job: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeSimulationJobResponse {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "clientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "compute")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compute: Option<ComputeResponse>,
#[serde(rename = "dataSources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_sources: Option<Vec<DataSource>>,
#[serde(rename = "failureBehavior")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_behavior: Option<String>,
#[serde(rename = "failureCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_code: Option<String>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "iamRole")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_role: Option<String>,
#[serde(rename = "lastStartedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_started_at: Option<f64>,
#[serde(rename = "lastUpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_at: Option<f64>,
#[serde(rename = "loggingConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub logging_config: Option<LoggingConfig>,
#[serde(rename = "maxJobDurationInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_job_duration_in_seconds: Option<i64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "networkInterface")]
#[serde(skip_serializing_if = "Option::is_none")]
pub network_interface: Option<NetworkInterface>,
#[serde(rename = "outputLocation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_location: Option<OutputLocation>,
#[serde(rename = "robotApplications")]
#[serde(skip_serializing_if = "Option::is_none")]
pub robot_applications: Option<Vec<RobotApplicationConfig>>,
#[serde(rename = "simulationApplications")]
#[serde(skip_serializing_if = "Option::is_none")]
pub simulation_applications: Option<Vec<SimulationApplicationConfig>>,
#[serde(rename = "simulationTimeMillis")]
#[serde(skip_serializing_if = "Option::is_none")]
pub simulation_time_millis: Option<i64>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "vpcConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_config: Option<VPCConfigResponse>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeWorldExportJobRequest {
#[serde(rename = "job")]
pub job: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeWorldExportJobResponse {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "clientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "failureCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_code: Option<String>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "iamRole")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_role: Option<String>,
#[serde(rename = "outputLocation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_location: Option<OutputLocation>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "worlds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub worlds: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeWorldGenerationJobRequest {
#[serde(rename = "job")]
pub job: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeWorldGenerationJobResponse {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "clientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "failureCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_code: Option<String>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "finishedWorldsSummary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub finished_worlds_summary: Option<FinishedWorldsSummary>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "template")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template: Option<String>,
#[serde(rename = "worldCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub world_count: Option<WorldCount>,
#[serde(rename = "worldTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub world_tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeWorldRequest {
#[serde(rename = "world")]
pub world: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeWorldResponse {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "generationJob")]
#[serde(skip_serializing_if = "Option::is_none")]
pub generation_job: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "template")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeWorldTemplateRequest {
#[serde(rename = "template")]
pub template: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeWorldTemplateResponse {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "clientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "lastUpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_at: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FailedCreateSimulationJobRequest {
#[serde(rename = "failedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed_at: Option<f64>,
#[serde(rename = "failureCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_code: Option<String>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "request")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request: Option<SimulationJobRequest>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FailureSummary {
#[serde(rename = "failures")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failures: Option<Vec<WorldFailure>>,
#[serde(rename = "totalFailureCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub total_failure_count: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Filter {
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "values")]
#[serde(skip_serializing_if = "Option::is_none")]
pub values: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FinishedWorldsSummary {
#[serde(rename = "failureSummary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_summary: Option<FailureSummary>,
#[serde(rename = "finishedCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub finished_count: Option<i64>,
#[serde(rename = "succeededWorlds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub succeeded_worlds: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Fleet {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "lastDeploymentJob")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_deployment_job: Option<String>,
#[serde(rename = "lastDeploymentStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_deployment_status: Option<String>,
#[serde(rename = "lastDeploymentTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_deployment_time: Option<f64>,
#[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 GetWorldTemplateBodyRequest {
#[serde(rename = "generationJob")]
#[serde(skip_serializing_if = "Option::is_none")]
pub generation_job: Option<String>,
#[serde(rename = "template")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetWorldTemplateBodyResponse {
#[serde(rename = "templateBody")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_body: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct LaunchConfig {
#[serde(rename = "environmentVariables")]
#[serde(skip_serializing_if = "Option::is_none")]
pub environment_variables: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "launchFile")]
pub launch_file: String,
#[serde(rename = "packageName")]
pub package_name: String,
#[serde(rename = "portForwardingConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port_forwarding_config: Option<PortForwardingConfig>,
#[serde(rename = "streamUI")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stream_ui: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDeploymentJobsRequest {
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDeploymentJobsResponse {
#[serde(rename = "deploymentJobs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_jobs: Option<Vec<DeploymentJob>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListFleetsRequest {
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListFleetsResponse {
#[serde(rename = "fleetDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fleet_details: Option<Vec<Fleet>>,
#[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 ListRobotApplicationsRequest {
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "versionQualifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version_qualifier: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListRobotApplicationsResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "robotApplicationSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub robot_application_summaries: Option<Vec<RobotApplicationSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListRobotsRequest {
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListRobotsResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "robots")]
#[serde(skip_serializing_if = "Option::is_none")]
pub robots: Option<Vec<Robot>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListSimulationApplicationsRequest {
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "versionQualifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version_qualifier: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListSimulationApplicationsResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "simulationApplicationSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub simulation_application_summaries: Option<Vec<SimulationApplicationSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListSimulationJobBatchesRequest {
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListSimulationJobBatchesResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "simulationJobBatchSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub simulation_job_batch_summaries: Option<Vec<SimulationJobBatchSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListSimulationJobsRequest {
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListSimulationJobsResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "simulationJobSummaries")]
pub simulation_job_summaries: Vec<SimulationJobSummary>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceRequest {
#[serde(rename = "resourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceResponse {
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListWorldExportJobsRequest {
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListWorldExportJobsResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "worldExportJobSummaries")]
pub world_export_job_summaries: Vec<WorldExportJobSummary>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListWorldGenerationJobsRequest {
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListWorldGenerationJobsResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "worldGenerationJobSummaries")]
pub world_generation_job_summaries: Vec<WorldGenerationJobSummary>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListWorldTemplatesRequest {
#[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 ListWorldTemplatesResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "templateSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_summaries: Option<Vec<TemplateSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListWorldsRequest {
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListWorldsResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "worldSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub world_summaries: Option<Vec<WorldSummary>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct LoggingConfig {
#[serde(rename = "recordAllRosTopics")]
pub record_all_ros_topics: bool,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct NetworkInterface {
#[serde(rename = "networkInterfaceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub network_interface_id: Option<String>,
#[serde(rename = "privateIpAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub private_ip_address: Option<String>,
#[serde(rename = "publicIpAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub public_ip_address: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct OutputLocation {
#[serde(rename = "s3Bucket")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s_3_bucket: Option<String>,
#[serde(rename = "s3Prefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s_3_prefix: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct PortForwardingConfig {
#[serde(rename = "portMappings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port_mappings: Option<Vec<PortMapping>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct PortMapping {
#[serde(rename = "applicationPort")]
pub application_port: i64,
#[serde(rename = "enableOnPublicIp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_on_public_ip: Option<bool>,
#[serde(rename = "jobPort")]
pub job_port: i64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProgressDetail {
#[serde(rename = "currentProgress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub current_progress: Option<String>,
#[serde(rename = "estimatedTimeRemainingSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub estimated_time_remaining_seconds: Option<i64>,
#[serde(rename = "percentDone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub percent_done: Option<f32>,
#[serde(rename = "targetResource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_resource: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RegisterRobotRequest {
#[serde(rename = "fleet")]
pub fleet: String,
#[serde(rename = "robot")]
pub robot: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RegisterRobotResponse {
#[serde(rename = "fleet")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fleet: Option<String>,
#[serde(rename = "robot")]
#[serde(skip_serializing_if = "Option::is_none")]
pub robot: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct RenderingEngine {
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RestartSimulationJobRequest {
#[serde(rename = "job")]
pub job: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RestartSimulationJobResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Robot {
#[serde(rename = "architecture")]
#[serde(skip_serializing_if = "Option::is_none")]
pub architecture: Option<String>,
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "fleetArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fleet_arn: Option<String>,
#[serde(rename = "greenGrassGroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub green_grass_group_id: Option<String>,
#[serde(rename = "lastDeploymentJob")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_deployment_job: Option<String>,
#[serde(rename = "lastDeploymentTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_deployment_time: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct RobotApplicationConfig {
#[serde(rename = "application")]
pub application: String,
#[serde(rename = "applicationVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_version: Option<String>,
#[serde(rename = "launchConfig")]
pub launch_config: LaunchConfig,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RobotApplicationSummary {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "lastUpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_at: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "robotSoftwareSuite")]
#[serde(skip_serializing_if = "Option::is_none")]
pub robot_software_suite: Option<RobotSoftwareSuite>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RobotDeployment {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "deploymentFinishTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_finish_time: Option<f64>,
#[serde(rename = "deploymentStartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_start_time: Option<f64>,
#[serde(rename = "failureCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_code: Option<String>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "progressDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub progress_detail: Option<ProgressDetail>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct RobotSoftwareSuite {
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct S3KeyOutput {
#[serde(rename = "etag")]
#[serde(skip_serializing_if = "Option::is_none")]
pub etag: Option<String>,
#[serde(rename = "s3Key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s_3_key: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct S3Object {
#[serde(rename = "bucket")]
pub bucket: String,
#[serde(rename = "etag")]
#[serde(skip_serializing_if = "Option::is_none")]
pub etag: Option<String>,
#[serde(rename = "key")]
pub key: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SimulationApplicationConfig {
#[serde(rename = "application")]
pub application: String,
#[serde(rename = "applicationVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub application_version: Option<String>,
#[serde(rename = "launchConfig")]
pub launch_config: LaunchConfig,
#[serde(rename = "worldConfigs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub world_configs: Option<Vec<WorldConfig>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SimulationApplicationSummary {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "lastUpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_at: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "robotSoftwareSuite")]
#[serde(skip_serializing_if = "Option::is_none")]
pub robot_software_suite: Option<RobotSoftwareSuite>,
#[serde(rename = "simulationSoftwareSuite")]
#[serde(skip_serializing_if = "Option::is_none")]
pub simulation_software_suite: Option<SimulationSoftwareSuite>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SimulationJob {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "clientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "compute")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compute: Option<ComputeResponse>,
#[serde(rename = "dataSources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_sources: Option<Vec<DataSource>>,
#[serde(rename = "failureBehavior")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_behavior: Option<String>,
#[serde(rename = "failureCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_code: Option<String>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "iamRole")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_role: Option<String>,
#[serde(rename = "lastStartedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_started_at: Option<f64>,
#[serde(rename = "lastUpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_at: Option<f64>,
#[serde(rename = "loggingConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub logging_config: Option<LoggingConfig>,
#[serde(rename = "maxJobDurationInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_job_duration_in_seconds: Option<i64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "networkInterface")]
#[serde(skip_serializing_if = "Option::is_none")]
pub network_interface: Option<NetworkInterface>,
#[serde(rename = "outputLocation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_location: Option<OutputLocation>,
#[serde(rename = "robotApplications")]
#[serde(skip_serializing_if = "Option::is_none")]
pub robot_applications: Option<Vec<RobotApplicationConfig>>,
#[serde(rename = "simulationApplications")]
#[serde(skip_serializing_if = "Option::is_none")]
pub simulation_applications: Option<Vec<SimulationApplicationConfig>>,
#[serde(rename = "simulationTimeMillis")]
#[serde(skip_serializing_if = "Option::is_none")]
pub simulation_time_millis: Option<i64>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "vpcConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_config: Option<VPCConfigResponse>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SimulationJobBatchSummary {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "createdRequestCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_request_count: Option<i64>,
#[serde(rename = "failedRequestCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed_request_count: Option<i64>,
#[serde(rename = "lastUpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_at: Option<f64>,
#[serde(rename = "pendingRequestCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pending_request_count: Option<i64>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SimulationJobRequest {
#[serde(rename = "compute")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compute: Option<Compute>,
#[serde(rename = "dataSources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_sources: Option<Vec<DataSourceConfig>>,
#[serde(rename = "failureBehavior")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_behavior: Option<String>,
#[serde(rename = "iamRole")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_role: Option<String>,
#[serde(rename = "loggingConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub logging_config: Option<LoggingConfig>,
#[serde(rename = "maxJobDurationInSeconds")]
pub max_job_duration_in_seconds: i64,
#[serde(rename = "outputLocation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_location: Option<OutputLocation>,
#[serde(rename = "robotApplications")]
#[serde(skip_serializing_if = "Option::is_none")]
pub robot_applications: Option<Vec<RobotApplicationConfig>>,
#[serde(rename = "simulationApplications")]
#[serde(skip_serializing_if = "Option::is_none")]
pub simulation_applications: Option<Vec<SimulationApplicationConfig>>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "useDefaultApplications")]
#[serde(skip_serializing_if = "Option::is_none")]
pub use_default_applications: Option<bool>,
#[serde(rename = "vpcConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_config: Option<VPCConfig>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SimulationJobSummary {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "dataSourceNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_source_names: Option<Vec<String>>,
#[serde(rename = "lastUpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_at: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "robotApplicationNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub robot_application_names: Option<Vec<String>>,
#[serde(rename = "simulationApplicationNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub simulation_application_names: Option<Vec<String>>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SimulationSoftwareSuite {
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Source {
#[serde(rename = "architecture")]
#[serde(skip_serializing_if = "Option::is_none")]
pub architecture: Option<String>,
#[serde(rename = "etag")]
#[serde(skip_serializing_if = "Option::is_none")]
pub etag: Option<String>,
#[serde(rename = "s3Bucket")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s_3_bucket: Option<String>,
#[serde(rename = "s3Key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s_3_key: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SourceConfig {
#[serde(rename = "architecture")]
#[serde(skip_serializing_if = "Option::is_none")]
pub architecture: Option<String>,
#[serde(rename = "s3Bucket")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s_3_bucket: Option<String>,
#[serde(rename = "s3Key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s_3_key: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartSimulationJobBatchRequest {
#[serde(rename = "batchPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub batch_policy: Option<BatchPolicy>,
#[serde(rename = "clientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "createSimulationJobRequests")]
pub create_simulation_job_requests: Vec<SimulationJobRequest>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartSimulationJobBatchResponse {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "batchPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub batch_policy: Option<BatchPolicy>,
#[serde(rename = "clientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "createdRequests")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_requests: Option<Vec<SimulationJobSummary>>,
#[serde(rename = "failedRequests")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed_requests: Option<Vec<FailedCreateSimulationJobRequest>>,
#[serde(rename = "failureCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_code: Option<String>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "pendingRequests")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pending_requests: Option<Vec<SimulationJobRequest>>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SyncDeploymentJobRequest {
#[serde(rename = "clientRequestToken")]
pub client_request_token: String,
#[serde(rename = "fleet")]
pub fleet: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SyncDeploymentJobResponse {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "deploymentApplicationConfigs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_application_configs: Option<Vec<DeploymentApplicationConfig>>,
#[serde(rename = "deploymentConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_config: Option<DeploymentConfig>,
#[serde(rename = "failureCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_code: Option<String>,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<String>,
#[serde(rename = "fleet")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fleet: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "resourceArn")]
pub resource_arn: String,
#[serde(rename = "tags")]
pub tags: ::std::collections::HashMap<String, String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TagResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TemplateLocation {
#[serde(rename = "s3Bucket")]
pub s_3_bucket: String,
#[serde(rename = "s3Key")]
pub s_3_key: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TemplateSummary {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "lastUpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_at: Option<f64>,
#[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 UntagResourceRequest {
#[serde(rename = "resourceArn")]
pub resource_arn: String,
#[serde(rename = "tagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UntagResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateRobotApplicationRequest {
#[serde(rename = "application")]
pub application: String,
#[serde(rename = "currentRevisionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub current_revision_id: Option<String>,
#[serde(rename = "robotSoftwareSuite")]
pub robot_software_suite: RobotSoftwareSuite,
#[serde(rename = "sources")]
pub sources: Vec<SourceConfig>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateRobotApplicationResponse {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "lastUpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_at: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "revisionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_id: Option<String>,
#[serde(rename = "robotSoftwareSuite")]
#[serde(skip_serializing_if = "Option::is_none")]
pub robot_software_suite: Option<RobotSoftwareSuite>,
#[serde(rename = "sources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sources: Option<Vec<Source>>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateSimulationApplicationRequest {
#[serde(rename = "application")]
pub application: String,
#[serde(rename = "currentRevisionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub current_revision_id: Option<String>,
#[serde(rename = "renderingEngine")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rendering_engine: Option<RenderingEngine>,
#[serde(rename = "robotSoftwareSuite")]
pub robot_software_suite: RobotSoftwareSuite,
#[serde(rename = "simulationSoftwareSuite")]
pub simulation_software_suite: SimulationSoftwareSuite,
#[serde(rename = "sources")]
pub sources: Vec<SourceConfig>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateSimulationApplicationResponse {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "lastUpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_at: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "renderingEngine")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rendering_engine: Option<RenderingEngine>,
#[serde(rename = "revisionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_id: Option<String>,
#[serde(rename = "robotSoftwareSuite")]
#[serde(skip_serializing_if = "Option::is_none")]
pub robot_software_suite: Option<RobotSoftwareSuite>,
#[serde(rename = "simulationSoftwareSuite")]
#[serde(skip_serializing_if = "Option::is_none")]
pub simulation_software_suite: Option<SimulationSoftwareSuite>,
#[serde(rename = "sources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sources: Option<Vec<Source>>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateWorldTemplateRequest {
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "template")]
pub template: String,
#[serde(rename = "templateBody")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_body: Option<String>,
#[serde(rename = "templateLocation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_location: Option<TemplateLocation>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateWorldTemplateResponse {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "lastUpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_at: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct VPCConfig {
#[serde(rename = "assignPublicIp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub assign_public_ip: Option<bool>,
#[serde(rename = "securityGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_groups: Option<Vec<String>>,
#[serde(rename = "subnets")]
pub subnets: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct VPCConfigResponse {
#[serde(rename = "assignPublicIp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub assign_public_ip: Option<bool>,
#[serde(rename = "securityGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_groups: Option<Vec<String>>,
#[serde(rename = "subnets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnets: Option<Vec<String>>,
#[serde(rename = "vpcId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct WorldConfig {
#[serde(rename = "world")]
#[serde(skip_serializing_if = "Option::is_none")]
pub world: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct WorldCount {
#[serde(rename = "floorplanCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub floorplan_count: Option<i64>,
#[serde(rename = "interiorCountPerFloorplan")]
#[serde(skip_serializing_if = "Option::is_none")]
pub interior_count_per_floorplan: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct WorldExportJobSummary {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "worlds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub worlds: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct WorldFailure {
#[serde(rename = "failureCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_code: Option<String>,
#[serde(rename = "failureCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_count: Option<i64>,
#[serde(rename = "sampleFailureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sample_failure_reason: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct WorldGenerationJobSummary {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "failedWorldCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed_world_count: Option<i64>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "succeededWorldCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub succeeded_world_count: Option<i64>,
#[serde(rename = "template")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template: Option<String>,
#[serde(rename = "worldCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub world_count: Option<WorldCount>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct WorldSummary {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "generationJob")]
#[serde(skip_serializing_if = "Option::is_none")]
pub generation_job: Option<String>,
#[serde(rename = "template")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum BatchDeleteWorldsError {
InternalServer(String),
InvalidParameter(String),
Throttling(String),
}
impl BatchDeleteWorldsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<BatchDeleteWorldsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(BatchDeleteWorldsError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(BatchDeleteWorldsError::InvalidParameter(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(BatchDeleteWorldsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BatchDeleteWorldsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchDeleteWorldsError::InternalServer(ref cause) => write!(f, "{}", cause),
BatchDeleteWorldsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
BatchDeleteWorldsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for BatchDeleteWorldsError {}
#[derive(Debug, PartialEq)]
pub enum BatchDescribeSimulationJobError {
InternalServer(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl BatchDescribeSimulationJobError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<BatchDescribeSimulationJobError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(BatchDescribeSimulationJobError::InternalServer(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(BatchDescribeSimulationJobError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(BatchDescribeSimulationJobError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(BatchDescribeSimulationJobError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BatchDescribeSimulationJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchDescribeSimulationJobError::InternalServer(ref cause) => write!(f, "{}", cause),
BatchDescribeSimulationJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
BatchDescribeSimulationJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
BatchDescribeSimulationJobError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for BatchDescribeSimulationJobError {}
#[derive(Debug, PartialEq)]
pub enum CancelDeploymentJobError {
InternalServer(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl CancelDeploymentJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CancelDeploymentJobError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(CancelDeploymentJobError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(CancelDeploymentJobError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CancelDeploymentJobError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(CancelDeploymentJobError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CancelDeploymentJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CancelDeploymentJobError::InternalServer(ref cause) => write!(f, "{}", cause),
CancelDeploymentJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CancelDeploymentJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CancelDeploymentJobError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CancelDeploymentJobError {}
#[derive(Debug, PartialEq)]
pub enum CancelSimulationJobError {
InternalServer(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl CancelSimulationJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CancelSimulationJobError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(CancelSimulationJobError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(CancelSimulationJobError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CancelSimulationJobError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(CancelSimulationJobError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CancelSimulationJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CancelSimulationJobError::InternalServer(ref cause) => write!(f, "{}", cause),
CancelSimulationJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CancelSimulationJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CancelSimulationJobError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CancelSimulationJobError {}
#[derive(Debug, PartialEq)]
pub enum CancelSimulationJobBatchError {
InternalServer(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl CancelSimulationJobBatchError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CancelSimulationJobBatchError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(CancelSimulationJobBatchError::InternalServer(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(CancelSimulationJobBatchError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CancelSimulationJobBatchError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(CancelSimulationJobBatchError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CancelSimulationJobBatchError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CancelSimulationJobBatchError::InternalServer(ref cause) => write!(f, "{}", cause),
CancelSimulationJobBatchError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CancelSimulationJobBatchError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CancelSimulationJobBatchError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CancelSimulationJobBatchError {}
#[derive(Debug, PartialEq)]
pub enum CancelWorldExportJobError {
InternalServer(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl CancelWorldExportJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CancelWorldExportJobError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(CancelWorldExportJobError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(CancelWorldExportJobError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CancelWorldExportJobError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(CancelWorldExportJobError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CancelWorldExportJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CancelWorldExportJobError::InternalServer(ref cause) => write!(f, "{}", cause),
CancelWorldExportJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CancelWorldExportJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CancelWorldExportJobError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CancelWorldExportJobError {}
#[derive(Debug, PartialEq)]
pub enum CancelWorldGenerationJobError {
InternalServer(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl CancelWorldGenerationJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CancelWorldGenerationJobError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(CancelWorldGenerationJobError::InternalServer(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(CancelWorldGenerationJobError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CancelWorldGenerationJobError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(CancelWorldGenerationJobError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CancelWorldGenerationJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CancelWorldGenerationJobError::InternalServer(ref cause) => write!(f, "{}", cause),
CancelWorldGenerationJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CancelWorldGenerationJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CancelWorldGenerationJobError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CancelWorldGenerationJobError {}
#[derive(Debug, PartialEq)]
pub enum CreateDeploymentJobError {
ConcurrentDeployment(String),
IdempotentParameterMismatch(String),
InternalServer(String),
InvalidParameter(String),
LimitExceeded(String),
ResourceNotFound(String),
Throttling(String),
}
impl CreateDeploymentJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDeploymentJobError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ConcurrentDeploymentException" => {
return RusotoError::Service(CreateDeploymentJobError::ConcurrentDeployment(
err.msg,
))
}
"IdempotentParameterMismatchException" => {
return RusotoError::Service(
CreateDeploymentJobError::IdempotentParameterMismatch(err.msg),
)
}
"InternalServerException" => {
return RusotoError::Service(CreateDeploymentJobError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateDeploymentJobError::InvalidParameter(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(CreateDeploymentJobError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateDeploymentJobError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(CreateDeploymentJobError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDeploymentJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDeploymentJobError::ConcurrentDeployment(ref cause) => write!(f, "{}", cause),
CreateDeploymentJobError::IdempotentParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
CreateDeploymentJobError::InternalServer(ref cause) => write!(f, "{}", cause),
CreateDeploymentJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateDeploymentJobError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateDeploymentJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateDeploymentJobError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDeploymentJobError {}
#[derive(Debug, PartialEq)]
pub enum CreateFleetError {
InternalServer(String),
InvalidParameter(String),
LimitExceeded(String),
Throttling(String),
}
impl CreateFleetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateFleetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(CreateFleetError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateFleetError::InvalidParameter(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateFleetError::LimitExceeded(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(CreateFleetError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateFleetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateFleetError::InternalServer(ref cause) => write!(f, "{}", cause),
CreateFleetError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateFleetError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateFleetError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateFleetError {}
#[derive(Debug, PartialEq)]
pub enum CreateRobotError {
InternalServer(String),
InvalidParameter(String),
LimitExceeded(String),
ResourceAlreadyExists(String),
Throttling(String),
}
impl CreateRobotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateRobotError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(CreateRobotError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateRobotError::InvalidParameter(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateRobotError::LimitExceeded(err.msg))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(CreateRobotError::ResourceAlreadyExists(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(CreateRobotError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateRobotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateRobotError::InternalServer(ref cause) => write!(f, "{}", cause),
CreateRobotError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateRobotError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateRobotError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateRobotError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateRobotError {}
#[derive(Debug, PartialEq)]
pub enum CreateRobotApplicationError {
IdempotentParameterMismatch(String),
InternalServer(String),
InvalidParameter(String),
LimitExceeded(String),
ResourceAlreadyExists(String),
Throttling(String),
}
impl CreateRobotApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateRobotApplicationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"IdempotentParameterMismatchException" => {
return RusotoError::Service(
CreateRobotApplicationError::IdempotentParameterMismatch(err.msg),
)
}
"InternalServerException" => {
return RusotoError::Service(CreateRobotApplicationError::InternalServer(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateRobotApplicationError::InvalidParameter(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(CreateRobotApplicationError::LimitExceeded(
err.msg,
))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(
CreateRobotApplicationError::ResourceAlreadyExists(err.msg),
)
}
"ThrottlingException" => {
return RusotoError::Service(CreateRobotApplicationError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateRobotApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateRobotApplicationError::IdempotentParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
CreateRobotApplicationError::InternalServer(ref cause) => write!(f, "{}", cause),
CreateRobotApplicationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateRobotApplicationError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateRobotApplicationError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateRobotApplicationError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateRobotApplicationError {}
#[derive(Debug, PartialEq)]
pub enum CreateRobotApplicationVersionError {
IdempotentParameterMismatch(String),
InternalServer(String),
InvalidParameter(String),
LimitExceeded(String),
Throttling(String),
}
impl CreateRobotApplicationVersionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateRobotApplicationVersionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"IdempotentParameterMismatchException" => {
return RusotoError::Service(
CreateRobotApplicationVersionError::IdempotentParameterMismatch(err.msg),
)
}
"InternalServerException" => {
return RusotoError::Service(
CreateRobotApplicationVersionError::InternalServer(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(
CreateRobotApplicationVersionError::InvalidParameter(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(CreateRobotApplicationVersionError::LimitExceeded(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(CreateRobotApplicationVersionError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateRobotApplicationVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateRobotApplicationVersionError::IdempotentParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
CreateRobotApplicationVersionError::InternalServer(ref cause) => write!(f, "{}", cause),
CreateRobotApplicationVersionError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
CreateRobotApplicationVersionError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateRobotApplicationVersionError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateRobotApplicationVersionError {}
#[derive(Debug, PartialEq)]
pub enum CreateSimulationApplicationError {
IdempotentParameterMismatch(String),
InternalServer(String),
InvalidParameter(String),
LimitExceeded(String),
ResourceAlreadyExists(String),
Throttling(String),
}
impl CreateSimulationApplicationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateSimulationApplicationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"IdempotentParameterMismatchException" => {
return RusotoError::Service(
CreateSimulationApplicationError::IdempotentParameterMismatch(err.msg),
)
}
"InternalServerException" => {
return RusotoError::Service(CreateSimulationApplicationError::InternalServer(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(
CreateSimulationApplicationError::InvalidParameter(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(CreateSimulationApplicationError::LimitExceeded(
err.msg,
))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(
CreateSimulationApplicationError::ResourceAlreadyExists(err.msg),
)
}
"ThrottlingException" => {
return RusotoError::Service(CreateSimulationApplicationError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateSimulationApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateSimulationApplicationError::IdempotentParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
CreateSimulationApplicationError::InternalServer(ref cause) => write!(f, "{}", cause),
CreateSimulationApplicationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateSimulationApplicationError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateSimulationApplicationError::ResourceAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
CreateSimulationApplicationError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateSimulationApplicationError {}
#[derive(Debug, PartialEq)]
pub enum CreateSimulationApplicationVersionError {
IdempotentParameterMismatch(String),
InternalServer(String),
InvalidParameter(String),
LimitExceeded(String),
Throttling(String),
}
impl CreateSimulationApplicationVersionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateSimulationApplicationVersionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"IdempotentParameterMismatchException" => {
return RusotoError::Service(
CreateSimulationApplicationVersionError::IdempotentParameterMismatch(
err.msg,
),
)
}
"InternalServerException" => {
return RusotoError::Service(
CreateSimulationApplicationVersionError::InternalServer(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(
CreateSimulationApplicationVersionError::InvalidParameter(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(
CreateSimulationApplicationVersionError::LimitExceeded(err.msg),
)
}
"ThrottlingException" => {
return RusotoError::Service(
CreateSimulationApplicationVersionError::Throttling(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateSimulationApplicationVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateSimulationApplicationVersionError::IdempotentParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
CreateSimulationApplicationVersionError::InternalServer(ref cause) => {
write!(f, "{}", cause)
}
CreateSimulationApplicationVersionError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
CreateSimulationApplicationVersionError::LimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
CreateSimulationApplicationVersionError::Throttling(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateSimulationApplicationVersionError {}
#[derive(Debug, PartialEq)]
pub enum CreateSimulationJobError {
IdempotentParameterMismatch(String),
InternalServer(String),
InvalidParameter(String),
LimitExceeded(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl CreateSimulationJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateSimulationJobError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"IdempotentParameterMismatchException" => {
return RusotoError::Service(
CreateSimulationJobError::IdempotentParameterMismatch(err.msg),
)
}
"InternalServerException" => {
return RusotoError::Service(CreateSimulationJobError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateSimulationJobError::InvalidParameter(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(CreateSimulationJobError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateSimulationJobError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(CreateSimulationJobError::ServiceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(CreateSimulationJobError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateSimulationJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateSimulationJobError::IdempotentParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
CreateSimulationJobError::InternalServer(ref cause) => write!(f, "{}", cause),
CreateSimulationJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateSimulationJobError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateSimulationJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateSimulationJobError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
CreateSimulationJobError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateSimulationJobError {}
#[derive(Debug, PartialEq)]
pub enum CreateWorldExportJobError {
IdempotentParameterMismatch(String),
InternalServer(String),
InvalidParameter(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl CreateWorldExportJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateWorldExportJobError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"IdempotentParameterMismatchException" => {
return RusotoError::Service(
CreateWorldExportJobError::IdempotentParameterMismatch(err.msg),
)
}
"InternalServerException" => {
return RusotoError::Service(CreateWorldExportJobError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateWorldExportJobError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateWorldExportJobError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(CreateWorldExportJobError::ServiceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(CreateWorldExportJobError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateWorldExportJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateWorldExportJobError::IdempotentParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
CreateWorldExportJobError::InternalServer(ref cause) => write!(f, "{}", cause),
CreateWorldExportJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateWorldExportJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateWorldExportJobError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
CreateWorldExportJobError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateWorldExportJobError {}
#[derive(Debug, PartialEq)]
pub enum CreateWorldGenerationJobError {
IdempotentParameterMismatch(String),
InternalServer(String),
InvalidParameter(String),
LimitExceeded(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl CreateWorldGenerationJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateWorldGenerationJobError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"IdempotentParameterMismatchException" => {
return RusotoError::Service(
CreateWorldGenerationJobError::IdempotentParameterMismatch(err.msg),
)
}
"InternalServerException" => {
return RusotoError::Service(CreateWorldGenerationJobError::InternalServer(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateWorldGenerationJobError::InvalidParameter(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(CreateWorldGenerationJobError::LimitExceeded(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateWorldGenerationJobError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(CreateWorldGenerationJobError::ServiceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(CreateWorldGenerationJobError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateWorldGenerationJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateWorldGenerationJobError::IdempotentParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
CreateWorldGenerationJobError::InternalServer(ref cause) => write!(f, "{}", cause),
CreateWorldGenerationJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateWorldGenerationJobError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateWorldGenerationJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateWorldGenerationJobError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
CreateWorldGenerationJobError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateWorldGenerationJobError {}
#[derive(Debug, PartialEq)]
pub enum CreateWorldTemplateError {
InternalServer(String),
InvalidParameter(String),
LimitExceeded(String),
ResourceAlreadyExists(String),
ResourceNotFound(String),
Throttling(String),
}
impl CreateWorldTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateWorldTemplateError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(CreateWorldTemplateError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(CreateWorldTemplateError::InvalidParameter(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(CreateWorldTemplateError::LimitExceeded(err.msg))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(CreateWorldTemplateError::ResourceAlreadyExists(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateWorldTemplateError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(CreateWorldTemplateError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateWorldTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateWorldTemplateError::InternalServer(ref cause) => write!(f, "{}", cause),
CreateWorldTemplateError::InvalidParameter(ref cause) => write!(f, "{}", cause),
CreateWorldTemplateError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateWorldTemplateError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateWorldTemplateError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateWorldTemplateError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateWorldTemplateError {}
#[derive(Debug, PartialEq)]
pub enum DeleteFleetError {
InternalServer(String),
InvalidParameter(String),
Throttling(String),
}
impl DeleteFleetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteFleetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DeleteFleetError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DeleteFleetError::InvalidParameter(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DeleteFleetError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteFleetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteFleetError::InternalServer(ref cause) => write!(f, "{}", cause),
DeleteFleetError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteFleetError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteFleetError {}
#[derive(Debug, PartialEq)]
pub enum DeleteRobotError {
InternalServer(String),
InvalidParameter(String),
Throttling(String),
}
impl DeleteRobotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteRobotError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DeleteRobotError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DeleteRobotError::InvalidParameter(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DeleteRobotError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteRobotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteRobotError::InternalServer(ref cause) => write!(f, "{}", cause),
DeleteRobotError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteRobotError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteRobotError {}
#[derive(Debug, PartialEq)]
pub enum DeleteRobotApplicationError {
InternalServer(String),
InvalidParameter(String),
Throttling(String),
}
impl DeleteRobotApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteRobotApplicationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DeleteRobotApplicationError::InternalServer(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DeleteRobotApplicationError::InvalidParameter(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(DeleteRobotApplicationError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteRobotApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteRobotApplicationError::InternalServer(ref cause) => write!(f, "{}", cause),
DeleteRobotApplicationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteRobotApplicationError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteRobotApplicationError {}
#[derive(Debug, PartialEq)]
pub enum DeleteSimulationApplicationError {
InternalServer(String),
InvalidParameter(String),
Throttling(String),
}
impl DeleteSimulationApplicationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteSimulationApplicationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DeleteSimulationApplicationError::InternalServer(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(
DeleteSimulationApplicationError::InvalidParameter(err.msg),
)
}
"ThrottlingException" => {
return RusotoError::Service(DeleteSimulationApplicationError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteSimulationApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteSimulationApplicationError::InternalServer(ref cause) => write!(f, "{}", cause),
DeleteSimulationApplicationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteSimulationApplicationError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteSimulationApplicationError {}
#[derive(Debug, PartialEq)]
pub enum DeleteWorldTemplateError {
InternalServer(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl DeleteWorldTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteWorldTemplateError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DeleteWorldTemplateError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DeleteWorldTemplateError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteWorldTemplateError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(DeleteWorldTemplateError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteWorldTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteWorldTemplateError::InternalServer(ref cause) => write!(f, "{}", cause),
DeleteWorldTemplateError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeleteWorldTemplateError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteWorldTemplateError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteWorldTemplateError {}
#[derive(Debug, PartialEq)]
pub enum DeregisterRobotError {
InternalServer(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl DeregisterRobotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeregisterRobotError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DeregisterRobotError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DeregisterRobotError::InvalidParameter(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeregisterRobotError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DeregisterRobotError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeregisterRobotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeregisterRobotError::InternalServer(ref cause) => write!(f, "{}", cause),
DeregisterRobotError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DeregisterRobotError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeregisterRobotError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeregisterRobotError {}
#[derive(Debug, PartialEq)]
pub enum DescribeDeploymentJobError {
InternalServer(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl DescribeDeploymentJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeDeploymentJobError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DescribeDeploymentJobError::InternalServer(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeDeploymentJobError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeDeploymentJobError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(DescribeDeploymentJobError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeDeploymentJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeDeploymentJobError::InternalServer(ref cause) => write!(f, "{}", cause),
DescribeDeploymentJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeDeploymentJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeDeploymentJobError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeDeploymentJobError {}
#[derive(Debug, PartialEq)]
pub enum DescribeFleetError {
InternalServer(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl DescribeFleetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeFleetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DescribeFleetError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeFleetError::InvalidParameter(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeFleetError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DescribeFleetError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeFleetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeFleetError::InternalServer(ref cause) => write!(f, "{}", cause),
DescribeFleetError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeFleetError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeFleetError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeFleetError {}
#[derive(Debug, PartialEq)]
pub enum DescribeRobotError {
InternalServer(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl DescribeRobotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeRobotError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DescribeRobotError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeRobotError::InvalidParameter(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeRobotError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DescribeRobotError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeRobotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeRobotError::InternalServer(ref cause) => write!(f, "{}", cause),
DescribeRobotError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeRobotError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeRobotError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeRobotError {}
#[derive(Debug, PartialEq)]
pub enum DescribeRobotApplicationError {
InternalServer(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl DescribeRobotApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeRobotApplicationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DescribeRobotApplicationError::InternalServer(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeRobotApplicationError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeRobotApplicationError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(DescribeRobotApplicationError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeRobotApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeRobotApplicationError::InternalServer(ref cause) => write!(f, "{}", cause),
DescribeRobotApplicationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeRobotApplicationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeRobotApplicationError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeRobotApplicationError {}
#[derive(Debug, PartialEq)]
pub enum DescribeSimulationApplicationError {
InternalServer(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl DescribeSimulationApplicationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeSimulationApplicationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(
DescribeSimulationApplicationError::InternalServer(err.msg),
)
}
"InvalidParameterException" => {
return RusotoError::Service(
DescribeSimulationApplicationError::InvalidParameter(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DescribeSimulationApplicationError::ResourceNotFound(err.msg),
)
}
"ThrottlingException" => {
return RusotoError::Service(DescribeSimulationApplicationError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeSimulationApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeSimulationApplicationError::InternalServer(ref cause) => write!(f, "{}", cause),
DescribeSimulationApplicationError::InvalidParameter(ref cause) => {
write!(f, "{}", cause)
}
DescribeSimulationApplicationError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
DescribeSimulationApplicationError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeSimulationApplicationError {}
#[derive(Debug, PartialEq)]
pub enum DescribeSimulationJobError {
InternalServer(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl DescribeSimulationJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeSimulationJobError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DescribeSimulationJobError::InternalServer(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeSimulationJobError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeSimulationJobError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(DescribeSimulationJobError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeSimulationJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeSimulationJobError::InternalServer(ref cause) => write!(f, "{}", cause),
DescribeSimulationJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeSimulationJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeSimulationJobError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeSimulationJobError {}
#[derive(Debug, PartialEq)]
pub enum DescribeSimulationJobBatchError {
InternalServer(String),
InvalidParameter(String),
ResourceNotFound(String),
}
impl DescribeSimulationJobBatchError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeSimulationJobBatchError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DescribeSimulationJobBatchError::InternalServer(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeSimulationJobBatchError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeSimulationJobBatchError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeSimulationJobBatchError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeSimulationJobBatchError::InternalServer(ref cause) => write!(f, "{}", cause),
DescribeSimulationJobBatchError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeSimulationJobBatchError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeSimulationJobBatchError {}
#[derive(Debug, PartialEq)]
pub enum DescribeWorldError {
InternalServer(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl DescribeWorldError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeWorldError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DescribeWorldError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeWorldError::InvalidParameter(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeWorldError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DescribeWorldError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeWorldError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeWorldError::InternalServer(ref cause) => write!(f, "{}", cause),
DescribeWorldError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeWorldError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeWorldError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeWorldError {}
#[derive(Debug, PartialEq)]
pub enum DescribeWorldExportJobError {
InternalServer(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl DescribeWorldExportJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeWorldExportJobError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DescribeWorldExportJobError::InternalServer(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeWorldExportJobError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeWorldExportJobError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(DescribeWorldExportJobError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeWorldExportJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeWorldExportJobError::InternalServer(ref cause) => write!(f, "{}", cause),
DescribeWorldExportJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeWorldExportJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeWorldExportJobError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeWorldExportJobError {}
#[derive(Debug, PartialEq)]
pub enum DescribeWorldGenerationJobError {
InternalServer(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl DescribeWorldGenerationJobError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeWorldGenerationJobError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DescribeWorldGenerationJobError::InternalServer(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeWorldGenerationJobError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeWorldGenerationJobError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(DescribeWorldGenerationJobError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeWorldGenerationJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeWorldGenerationJobError::InternalServer(ref cause) => write!(f, "{}", cause),
DescribeWorldGenerationJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeWorldGenerationJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeWorldGenerationJobError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeWorldGenerationJobError {}
#[derive(Debug, PartialEq)]
pub enum DescribeWorldTemplateError {
InternalServer(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl DescribeWorldTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeWorldTemplateError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(DescribeWorldTemplateError::InternalServer(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(DescribeWorldTemplateError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeWorldTemplateError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(DescribeWorldTemplateError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeWorldTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeWorldTemplateError::InternalServer(ref cause) => write!(f, "{}", cause),
DescribeWorldTemplateError::InvalidParameter(ref cause) => write!(f, "{}", cause),
DescribeWorldTemplateError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeWorldTemplateError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeWorldTemplateError {}
#[derive(Debug, PartialEq)]
pub enum GetWorldTemplateBodyError {
InternalServer(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl GetWorldTemplateBodyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetWorldTemplateBodyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(GetWorldTemplateBodyError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(GetWorldTemplateBodyError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetWorldTemplateBodyError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(GetWorldTemplateBodyError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetWorldTemplateBodyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetWorldTemplateBodyError::InternalServer(ref cause) => write!(f, "{}", cause),
GetWorldTemplateBodyError::InvalidParameter(ref cause) => write!(f, "{}", cause),
GetWorldTemplateBodyError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetWorldTemplateBodyError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetWorldTemplateBodyError {}
#[derive(Debug, PartialEq)]
pub enum ListDeploymentJobsError {
InternalServer(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl ListDeploymentJobsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDeploymentJobsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListDeploymentJobsError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListDeploymentJobsError::InvalidParameter(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListDeploymentJobsError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(ListDeploymentJobsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDeploymentJobsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDeploymentJobsError::InternalServer(ref cause) => write!(f, "{}", cause),
ListDeploymentJobsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListDeploymentJobsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListDeploymentJobsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDeploymentJobsError {}
#[derive(Debug, PartialEq)]
pub enum ListFleetsError {
InternalServer(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl ListFleetsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListFleetsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListFleetsError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListFleetsError::InvalidParameter(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListFleetsError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(ListFleetsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListFleetsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListFleetsError::InternalServer(ref cause) => write!(f, "{}", cause),
ListFleetsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListFleetsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListFleetsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListFleetsError {}
#[derive(Debug, PartialEq)]
pub enum ListRobotApplicationsError {
InternalServer(String),
InvalidParameter(String),
Throttling(String),
}
impl ListRobotApplicationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListRobotApplicationsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListRobotApplicationsError::InternalServer(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(ListRobotApplicationsError::InvalidParameter(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(ListRobotApplicationsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListRobotApplicationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListRobotApplicationsError::InternalServer(ref cause) => write!(f, "{}", cause),
ListRobotApplicationsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListRobotApplicationsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListRobotApplicationsError {}
#[derive(Debug, PartialEq)]
pub enum ListRobotsError {
InternalServer(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl ListRobotsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListRobotsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListRobotsError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListRobotsError::InvalidParameter(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListRobotsError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(ListRobotsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListRobotsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListRobotsError::InternalServer(ref cause) => write!(f, "{}", cause),
ListRobotsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListRobotsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListRobotsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListRobotsError {}
#[derive(Debug, PartialEq)]
pub enum ListSimulationApplicationsError {
InternalServer(String),
InvalidParameter(String),
Throttling(String),
}
impl ListSimulationApplicationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListSimulationApplicationsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListSimulationApplicationsError::InternalServer(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(ListSimulationApplicationsError::InvalidParameter(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(ListSimulationApplicationsError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListSimulationApplicationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListSimulationApplicationsError::InternalServer(ref cause) => write!(f, "{}", cause),
ListSimulationApplicationsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListSimulationApplicationsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListSimulationApplicationsError {}
#[derive(Debug, PartialEq)]
pub enum ListSimulationJobBatchesError {
InternalServer(String),
InvalidParameter(String),
}
impl ListSimulationJobBatchesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListSimulationJobBatchesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListSimulationJobBatchesError::InternalServer(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(ListSimulationJobBatchesError::InvalidParameter(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListSimulationJobBatchesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListSimulationJobBatchesError::InternalServer(ref cause) => write!(f, "{}", cause),
ListSimulationJobBatchesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListSimulationJobBatchesError {}
#[derive(Debug, PartialEq)]
pub enum ListSimulationJobsError {
InternalServer(String),
InvalidParameter(String),
Throttling(String),
}
impl ListSimulationJobsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListSimulationJobsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListSimulationJobsError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListSimulationJobsError::InvalidParameter(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(ListSimulationJobsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListSimulationJobsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListSimulationJobsError::InternalServer(ref cause) => write!(f, "{}", cause),
ListSimulationJobsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListSimulationJobsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListSimulationJobsError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
InternalServer(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListTagsForResourceError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListTagsForResourceError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(ListTagsForResourceError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsForResourceError::InternalServer(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum ListWorldExportJobsError {
InternalServer(String),
InvalidParameter(String),
Throttling(String),
}
impl ListWorldExportJobsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListWorldExportJobsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListWorldExportJobsError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListWorldExportJobsError::InvalidParameter(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(ListWorldExportJobsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListWorldExportJobsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListWorldExportJobsError::InternalServer(ref cause) => write!(f, "{}", cause),
ListWorldExportJobsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListWorldExportJobsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListWorldExportJobsError {}
#[derive(Debug, PartialEq)]
pub enum ListWorldGenerationJobsError {
InternalServer(String),
InvalidParameter(String),
Throttling(String),
}
impl ListWorldGenerationJobsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListWorldGenerationJobsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListWorldGenerationJobsError::InternalServer(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(ListWorldGenerationJobsError::InvalidParameter(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(ListWorldGenerationJobsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListWorldGenerationJobsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListWorldGenerationJobsError::InternalServer(ref cause) => write!(f, "{}", cause),
ListWorldGenerationJobsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListWorldGenerationJobsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListWorldGenerationJobsError {}
#[derive(Debug, PartialEq)]
pub enum ListWorldTemplatesError {
InternalServer(String),
InvalidParameter(String),
Throttling(String),
}
impl ListWorldTemplatesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListWorldTemplatesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListWorldTemplatesError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListWorldTemplatesError::InvalidParameter(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(ListWorldTemplatesError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListWorldTemplatesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListWorldTemplatesError::InternalServer(ref cause) => write!(f, "{}", cause),
ListWorldTemplatesError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListWorldTemplatesError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListWorldTemplatesError {}
#[derive(Debug, PartialEq)]
pub enum ListWorldsError {
InternalServer(String),
InvalidParameter(String),
Throttling(String),
}
impl ListWorldsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListWorldsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(ListWorldsError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(ListWorldsError::InvalidParameter(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(ListWorldsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListWorldsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListWorldsError::InternalServer(ref cause) => write!(f, "{}", cause),
ListWorldsError::InvalidParameter(ref cause) => write!(f, "{}", cause),
ListWorldsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListWorldsError {}
#[derive(Debug, PartialEq)]
pub enum RegisterRobotError {
InternalServer(String),
InvalidParameter(String),
LimitExceeded(String),
ResourceNotFound(String),
Throttling(String),
}
impl RegisterRobotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RegisterRobotError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(RegisterRobotError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(RegisterRobotError::InvalidParameter(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(RegisterRobotError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(RegisterRobotError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(RegisterRobotError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RegisterRobotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RegisterRobotError::InternalServer(ref cause) => write!(f, "{}", cause),
RegisterRobotError::InvalidParameter(ref cause) => write!(f, "{}", cause),
RegisterRobotError::LimitExceeded(ref cause) => write!(f, "{}", cause),
RegisterRobotError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
RegisterRobotError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RegisterRobotError {}
#[derive(Debug, PartialEq)]
pub enum RestartSimulationJobError {
InternalServer(String),
InvalidParameter(String),
LimitExceeded(String),
ResourceNotFound(String),
Throttling(String),
}
impl RestartSimulationJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RestartSimulationJobError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(RestartSimulationJobError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(RestartSimulationJobError::InvalidParameter(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(RestartSimulationJobError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(RestartSimulationJobError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(RestartSimulationJobError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RestartSimulationJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RestartSimulationJobError::InternalServer(ref cause) => write!(f, "{}", cause),
RestartSimulationJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
RestartSimulationJobError::LimitExceeded(ref cause) => write!(f, "{}", cause),
RestartSimulationJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
RestartSimulationJobError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RestartSimulationJobError {}
#[derive(Debug, PartialEq)]
pub enum StartSimulationJobBatchError {
IdempotentParameterMismatch(String),
InternalServer(String),
InvalidParameter(String),
LimitExceeded(String),
Throttling(String),
}
impl StartSimulationJobBatchError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartSimulationJobBatchError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"IdempotentParameterMismatchException" => {
return RusotoError::Service(
StartSimulationJobBatchError::IdempotentParameterMismatch(err.msg),
)
}
"InternalServerException" => {
return RusotoError::Service(StartSimulationJobBatchError::InternalServer(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(StartSimulationJobBatchError::InvalidParameter(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(StartSimulationJobBatchError::LimitExceeded(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(StartSimulationJobBatchError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartSimulationJobBatchError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartSimulationJobBatchError::IdempotentParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
StartSimulationJobBatchError::InternalServer(ref cause) => write!(f, "{}", cause),
StartSimulationJobBatchError::InvalidParameter(ref cause) => write!(f, "{}", cause),
StartSimulationJobBatchError::LimitExceeded(ref cause) => write!(f, "{}", cause),
StartSimulationJobBatchError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartSimulationJobBatchError {}
#[derive(Debug, PartialEq)]
pub enum SyncDeploymentJobError {
ConcurrentDeployment(String),
IdempotentParameterMismatch(String),
InternalServer(String),
InvalidParameter(String),
LimitExceeded(String),
ResourceNotFound(String),
Throttling(String),
}
impl SyncDeploymentJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SyncDeploymentJobError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ConcurrentDeploymentException" => {
return RusotoError::Service(SyncDeploymentJobError::ConcurrentDeployment(
err.msg,
))
}
"IdempotentParameterMismatchException" => {
return RusotoError::Service(
SyncDeploymentJobError::IdempotentParameterMismatch(err.msg),
)
}
"InternalServerException" => {
return RusotoError::Service(SyncDeploymentJobError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(SyncDeploymentJobError::InvalidParameter(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(SyncDeploymentJobError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(SyncDeploymentJobError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(SyncDeploymentJobError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SyncDeploymentJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SyncDeploymentJobError::ConcurrentDeployment(ref cause) => write!(f, "{}", cause),
SyncDeploymentJobError::IdempotentParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
SyncDeploymentJobError::InternalServer(ref cause) => write!(f, "{}", cause),
SyncDeploymentJobError::InvalidParameter(ref cause) => write!(f, "{}", cause),
SyncDeploymentJobError::LimitExceeded(ref cause) => write!(f, "{}", cause),
SyncDeploymentJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
SyncDeploymentJobError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SyncDeploymentJobError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
InternalServer(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(TagResourceError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(TagResourceError::InvalidParameter(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(TagResourceError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(TagResourceError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagResourceError::InternalServer(ref cause) => write!(f, "{}", cause),
TagResourceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
TagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
TagResourceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
InternalServer(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(UntagResourceError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(UntagResourceError::InvalidParameter(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UntagResourceError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(UntagResourceError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UntagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UntagResourceError::InternalServer(ref cause) => write!(f, "{}", cause),
UntagResourceError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UntagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UntagResourceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateRobotApplicationError {
InternalServer(String),
InvalidParameter(String),
LimitExceeded(String),
ResourceNotFound(String),
Throttling(String),
}
impl UpdateRobotApplicationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateRobotApplicationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(UpdateRobotApplicationError::InternalServer(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateRobotApplicationError::InvalidParameter(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(UpdateRobotApplicationError::LimitExceeded(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateRobotApplicationError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(UpdateRobotApplicationError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateRobotApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateRobotApplicationError::InternalServer(ref cause) => write!(f, "{}", cause),
UpdateRobotApplicationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateRobotApplicationError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateRobotApplicationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateRobotApplicationError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateRobotApplicationError {}
#[derive(Debug, PartialEq)]
pub enum UpdateSimulationApplicationError {
InternalServer(String),
InvalidParameter(String),
LimitExceeded(String),
ResourceNotFound(String),
Throttling(String),
}
impl UpdateSimulationApplicationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateSimulationApplicationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(UpdateSimulationApplicationError::InternalServer(
err.msg,
))
}
"InvalidParameterException" => {
return RusotoError::Service(
UpdateSimulationApplicationError::InvalidParameter(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(UpdateSimulationApplicationError::LimitExceeded(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(
UpdateSimulationApplicationError::ResourceNotFound(err.msg),
)
}
"ThrottlingException" => {
return RusotoError::Service(UpdateSimulationApplicationError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateSimulationApplicationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateSimulationApplicationError::InternalServer(ref cause) => write!(f, "{}", cause),
UpdateSimulationApplicationError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateSimulationApplicationError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateSimulationApplicationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateSimulationApplicationError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateSimulationApplicationError {}
#[derive(Debug, PartialEq)]
pub enum UpdateWorldTemplateError {
InternalServer(String),
InvalidParameter(String),
ResourceNotFound(String),
Throttling(String),
}
impl UpdateWorldTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateWorldTemplateError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerException" => {
return RusotoError::Service(UpdateWorldTemplateError::InternalServer(err.msg))
}
"InvalidParameterException" => {
return RusotoError::Service(UpdateWorldTemplateError::InvalidParameter(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateWorldTemplateError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(UpdateWorldTemplateError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateWorldTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateWorldTemplateError::InternalServer(ref cause) => write!(f, "{}", cause),
UpdateWorldTemplateError::InvalidParameter(ref cause) => write!(f, "{}", cause),
UpdateWorldTemplateError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateWorldTemplateError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateWorldTemplateError {}
#[async_trait]
pub trait Robomaker {
async fn batch_delete_worlds(
&self,
input: BatchDeleteWorldsRequest,
) -> Result<BatchDeleteWorldsResponse, RusotoError<BatchDeleteWorldsError>>;
async fn batch_describe_simulation_job(
&self,
input: BatchDescribeSimulationJobRequest,
) -> Result<BatchDescribeSimulationJobResponse, RusotoError<BatchDescribeSimulationJobError>>;
async fn cancel_deployment_job(
&self,
input: CancelDeploymentJobRequest,
) -> Result<CancelDeploymentJobResponse, RusotoError<CancelDeploymentJobError>>;
async fn cancel_simulation_job(
&self,
input: CancelSimulationJobRequest,
) -> Result<CancelSimulationJobResponse, RusotoError<CancelSimulationJobError>>;
async fn cancel_simulation_job_batch(
&self,
input: CancelSimulationJobBatchRequest,
) -> Result<CancelSimulationJobBatchResponse, RusotoError<CancelSimulationJobBatchError>>;
async fn cancel_world_export_job(
&self,
input: CancelWorldExportJobRequest,
) -> Result<CancelWorldExportJobResponse, RusotoError<CancelWorldExportJobError>>;
async fn cancel_world_generation_job(
&self,
input: CancelWorldGenerationJobRequest,
) -> Result<CancelWorldGenerationJobResponse, RusotoError<CancelWorldGenerationJobError>>;
async fn create_deployment_job(
&self,
input: CreateDeploymentJobRequest,
) -> Result<CreateDeploymentJobResponse, RusotoError<CreateDeploymentJobError>>;
async fn create_fleet(
&self,
input: CreateFleetRequest,
) -> Result<CreateFleetResponse, RusotoError<CreateFleetError>>;
async fn create_robot(
&self,
input: CreateRobotRequest,
) -> Result<CreateRobotResponse, RusotoError<CreateRobotError>>;
async fn create_robot_application(
&self,
input: CreateRobotApplicationRequest,
) -> Result<CreateRobotApplicationResponse, RusotoError<CreateRobotApplicationError>>;
async fn create_robot_application_version(
&self,
input: CreateRobotApplicationVersionRequest,
) -> Result<
CreateRobotApplicationVersionResponse,
RusotoError<CreateRobotApplicationVersionError>,
>;
async fn create_simulation_application(
&self,
input: CreateSimulationApplicationRequest,
) -> Result<CreateSimulationApplicationResponse, RusotoError<CreateSimulationApplicationError>>;
async fn create_simulation_application_version(
&self,
input: CreateSimulationApplicationVersionRequest,
) -> Result<
CreateSimulationApplicationVersionResponse,
RusotoError<CreateSimulationApplicationVersionError>,
>;
async fn create_simulation_job(
&self,
input: CreateSimulationJobRequest,
) -> Result<CreateSimulationJobResponse, RusotoError<CreateSimulationJobError>>;
async fn create_world_export_job(
&self,
input: CreateWorldExportJobRequest,
) -> Result<CreateWorldExportJobResponse, RusotoError<CreateWorldExportJobError>>;
async fn create_world_generation_job(
&self,
input: CreateWorldGenerationJobRequest,
) -> Result<CreateWorldGenerationJobResponse, RusotoError<CreateWorldGenerationJobError>>;
async fn create_world_template(
&self,
input: CreateWorldTemplateRequest,
) -> Result<CreateWorldTemplateResponse, RusotoError<CreateWorldTemplateError>>;
async fn delete_fleet(
&self,
input: DeleteFleetRequest,
) -> Result<DeleteFleetResponse, RusotoError<DeleteFleetError>>;
async fn delete_robot(
&self,
input: DeleteRobotRequest,
) -> Result<DeleteRobotResponse, RusotoError<DeleteRobotError>>;
async fn delete_robot_application(
&self,
input: DeleteRobotApplicationRequest,
) -> Result<DeleteRobotApplicationResponse, RusotoError<DeleteRobotApplicationError>>;
async fn delete_simulation_application(
&self,
input: DeleteSimulationApplicationRequest,
) -> Result<DeleteSimulationApplicationResponse, RusotoError<DeleteSimulationApplicationError>>;
async fn delete_world_template(
&self,
input: DeleteWorldTemplateRequest,
) -> Result<DeleteWorldTemplateResponse, RusotoError<DeleteWorldTemplateError>>;
async fn deregister_robot(
&self,
input: DeregisterRobotRequest,
) -> Result<DeregisterRobotResponse, RusotoError<DeregisterRobotError>>;
async fn describe_deployment_job(
&self,
input: DescribeDeploymentJobRequest,
) -> Result<DescribeDeploymentJobResponse, RusotoError<DescribeDeploymentJobError>>;
async fn describe_fleet(
&self,
input: DescribeFleetRequest,
) -> Result<DescribeFleetResponse, RusotoError<DescribeFleetError>>;
async fn describe_robot(
&self,
input: DescribeRobotRequest,
) -> Result<DescribeRobotResponse, RusotoError<DescribeRobotError>>;
async fn describe_robot_application(
&self,
input: DescribeRobotApplicationRequest,
) -> Result<DescribeRobotApplicationResponse, RusotoError<DescribeRobotApplicationError>>;
async fn describe_simulation_application(
&self,
input: DescribeSimulationApplicationRequest,
) -> Result<
DescribeSimulationApplicationResponse,
RusotoError<DescribeSimulationApplicationError>,
>;
async fn describe_simulation_job(
&self,
input: DescribeSimulationJobRequest,
) -> Result<DescribeSimulationJobResponse, RusotoError<DescribeSimulationJobError>>;
async fn describe_simulation_job_batch(
&self,
input: DescribeSimulationJobBatchRequest,
) -> Result<DescribeSimulationJobBatchResponse, RusotoError<DescribeSimulationJobBatchError>>;
async fn describe_world(
&self,
input: DescribeWorldRequest,
) -> Result<DescribeWorldResponse, RusotoError<DescribeWorldError>>;
async fn describe_world_export_job(
&self,
input: DescribeWorldExportJobRequest,
) -> Result<DescribeWorldExportJobResponse, RusotoError<DescribeWorldExportJobError>>;
async fn describe_world_generation_job(
&self,
input: DescribeWorldGenerationJobRequest,
) -> Result<DescribeWorldGenerationJobResponse, RusotoError<DescribeWorldGenerationJobError>>;
async fn describe_world_template(
&self,
input: DescribeWorldTemplateRequest,
) -> Result<DescribeWorldTemplateResponse, RusotoError<DescribeWorldTemplateError>>;
async fn get_world_template_body(
&self,
input: GetWorldTemplateBodyRequest,
) -> Result<GetWorldTemplateBodyResponse, RusotoError<GetWorldTemplateBodyError>>;
async fn list_deployment_jobs(
&self,
input: ListDeploymentJobsRequest,
) -> Result<ListDeploymentJobsResponse, RusotoError<ListDeploymentJobsError>>;
async fn list_fleets(
&self,
input: ListFleetsRequest,
) -> Result<ListFleetsResponse, RusotoError<ListFleetsError>>;
async fn list_robot_applications(
&self,
input: ListRobotApplicationsRequest,
) -> Result<ListRobotApplicationsResponse, RusotoError<ListRobotApplicationsError>>;
async fn list_robots(
&self,
input: ListRobotsRequest,
) -> Result<ListRobotsResponse, RusotoError<ListRobotsError>>;
async fn list_simulation_applications(
&self,
input: ListSimulationApplicationsRequest,
) -> Result<ListSimulationApplicationsResponse, RusotoError<ListSimulationApplicationsError>>;
async fn list_simulation_job_batches(
&self,
input: ListSimulationJobBatchesRequest,
) -> Result<ListSimulationJobBatchesResponse, RusotoError<ListSimulationJobBatchesError>>;
async fn list_simulation_jobs(
&self,
input: ListSimulationJobsRequest,
) -> Result<ListSimulationJobsResponse, RusotoError<ListSimulationJobsError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
async fn list_world_export_jobs(
&self,
input: ListWorldExportJobsRequest,
) -> Result<ListWorldExportJobsResponse, RusotoError<ListWorldExportJobsError>>;
async fn list_world_generation_jobs(
&self,
input: ListWorldGenerationJobsRequest,
) -> Result<ListWorldGenerationJobsResponse, RusotoError<ListWorldGenerationJobsError>>;
async fn list_world_templates(
&self,
input: ListWorldTemplatesRequest,
) -> Result<ListWorldTemplatesResponse, RusotoError<ListWorldTemplatesError>>;
async fn list_worlds(
&self,
input: ListWorldsRequest,
) -> Result<ListWorldsResponse, RusotoError<ListWorldsError>>;
async fn register_robot(
&self,
input: RegisterRobotRequest,
) -> Result<RegisterRobotResponse, RusotoError<RegisterRobotError>>;
async fn restart_simulation_job(
&self,
input: RestartSimulationJobRequest,
) -> Result<RestartSimulationJobResponse, RusotoError<RestartSimulationJobError>>;
async fn start_simulation_job_batch(
&self,
input: StartSimulationJobBatchRequest,
) -> Result<StartSimulationJobBatchResponse, RusotoError<StartSimulationJobBatchError>>;
async fn sync_deployment_job(
&self,
input: SyncDeploymentJobRequest,
) -> Result<SyncDeploymentJobResponse, RusotoError<SyncDeploymentJobError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>>;
async fn update_robot_application(
&self,
input: UpdateRobotApplicationRequest,
) -> Result<UpdateRobotApplicationResponse, RusotoError<UpdateRobotApplicationError>>;
async fn update_simulation_application(
&self,
input: UpdateSimulationApplicationRequest,
) -> Result<UpdateSimulationApplicationResponse, RusotoError<UpdateSimulationApplicationError>>;
async fn update_world_template(
&self,
input: UpdateWorldTemplateRequest,
) -> Result<UpdateWorldTemplateResponse, RusotoError<UpdateWorldTemplateError>>;
}
#[derive(Clone)]
pub struct RobomakerClient {
client: Client,
region: region::Region,
}
impl RobomakerClient {
pub fn new(region: region::Region) -> RobomakerClient {
RobomakerClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> RobomakerClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
RobomakerClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> RobomakerClient {
RobomakerClient { client, region }
}
}
#[async_trait]
impl Robomaker for RobomakerClient {
#[allow(unused_mut)]
async fn batch_delete_worlds(
&self,
input: BatchDeleteWorldsRequest,
) -> Result<BatchDeleteWorldsResponse, RusotoError<BatchDeleteWorldsError>> {
let request_uri = "/batchDeleteWorlds";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<BatchDeleteWorldsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(BatchDeleteWorldsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn batch_describe_simulation_job(
&self,
input: BatchDescribeSimulationJobRequest,
) -> Result<BatchDescribeSimulationJobResponse, RusotoError<BatchDescribeSimulationJobError>>
{
let request_uri = "/batchDescribeSimulationJob";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<BatchDescribeSimulationJobResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(BatchDescribeSimulationJobError::from_response(response))
}
}
#[allow(unused_mut)]
async fn cancel_deployment_job(
&self,
input: CancelDeploymentJobRequest,
) -> Result<CancelDeploymentJobResponse, RusotoError<CancelDeploymentJobError>> {
let request_uri = "/cancelDeploymentJob";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CancelDeploymentJobResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CancelDeploymentJobError::from_response(response))
}
}
#[allow(unused_mut)]
async fn cancel_simulation_job(
&self,
input: CancelSimulationJobRequest,
) -> Result<CancelSimulationJobResponse, RusotoError<CancelSimulationJobError>> {
let request_uri = "/cancelSimulationJob";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CancelSimulationJobResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CancelSimulationJobError::from_response(response))
}
}
#[allow(unused_mut)]
async fn cancel_simulation_job_batch(
&self,
input: CancelSimulationJobBatchRequest,
) -> Result<CancelSimulationJobBatchResponse, RusotoError<CancelSimulationJobBatchError>> {
let request_uri = "/cancelSimulationJobBatch";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CancelSimulationJobBatchResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CancelSimulationJobBatchError::from_response(response))
}
}
#[allow(unused_mut)]
async fn cancel_world_export_job(
&self,
input: CancelWorldExportJobRequest,
) -> Result<CancelWorldExportJobResponse, RusotoError<CancelWorldExportJobError>> {
let request_uri = "/cancelWorldExportJob";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CancelWorldExportJobResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CancelWorldExportJobError::from_response(response))
}
}
#[allow(unused_mut)]
async fn cancel_world_generation_job(
&self,
input: CancelWorldGenerationJobRequest,
) -> Result<CancelWorldGenerationJobResponse, RusotoError<CancelWorldGenerationJobError>> {
let request_uri = "/cancelWorldGenerationJob";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CancelWorldGenerationJobResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CancelWorldGenerationJobError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_deployment_job(
&self,
input: CreateDeploymentJobRequest,
) -> Result<CreateDeploymentJobResponse, RusotoError<CreateDeploymentJobError>> {
let request_uri = "/createDeploymentJob";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateDeploymentJobResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateDeploymentJobError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_fleet(
&self,
input: CreateFleetRequest,
) -> Result<CreateFleetResponse, RusotoError<CreateFleetError>> {
let request_uri = "/createFleet";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateFleetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateFleetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_robot(
&self,
input: CreateRobotRequest,
) -> Result<CreateRobotResponse, RusotoError<CreateRobotError>> {
let request_uri = "/createRobot";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateRobotResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateRobotError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_robot_application(
&self,
input: CreateRobotApplicationRequest,
) -> Result<CreateRobotApplicationResponse, RusotoError<CreateRobotApplicationError>> {
let request_uri = "/createRobotApplication";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateRobotApplicationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateRobotApplicationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_robot_application_version(
&self,
input: CreateRobotApplicationVersionRequest,
) -> Result<
CreateRobotApplicationVersionResponse,
RusotoError<CreateRobotApplicationVersionError>,
> {
let request_uri = "/createRobotApplicationVersion";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateRobotApplicationVersionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateRobotApplicationVersionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_simulation_application(
&self,
input: CreateSimulationApplicationRequest,
) -> Result<CreateSimulationApplicationResponse, RusotoError<CreateSimulationApplicationError>>
{
let request_uri = "/createSimulationApplication";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateSimulationApplicationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateSimulationApplicationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_simulation_application_version(
&self,
input: CreateSimulationApplicationVersionRequest,
) -> Result<
CreateSimulationApplicationVersionResponse,
RusotoError<CreateSimulationApplicationVersionError>,
> {
let request_uri = "/createSimulationApplicationVersion";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateSimulationApplicationVersionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateSimulationApplicationVersionError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn create_simulation_job(
&self,
input: CreateSimulationJobRequest,
) -> Result<CreateSimulationJobResponse, RusotoError<CreateSimulationJobError>> {
let request_uri = "/createSimulationJob";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateSimulationJobResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateSimulationJobError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_world_export_job(
&self,
input: CreateWorldExportJobRequest,
) -> Result<CreateWorldExportJobResponse, RusotoError<CreateWorldExportJobError>> {
let request_uri = "/createWorldExportJob";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateWorldExportJobResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateWorldExportJobError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_world_generation_job(
&self,
input: CreateWorldGenerationJobRequest,
) -> Result<CreateWorldGenerationJobResponse, RusotoError<CreateWorldGenerationJobError>> {
let request_uri = "/createWorldGenerationJob";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateWorldGenerationJobResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateWorldGenerationJobError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_world_template(
&self,
input: CreateWorldTemplateRequest,
) -> Result<CreateWorldTemplateResponse, RusotoError<CreateWorldTemplateError>> {
let request_uri = "/createWorldTemplate";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateWorldTemplateResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateWorldTemplateError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_fleet(
&self,
input: DeleteFleetRequest,
) -> Result<DeleteFleetResponse, RusotoError<DeleteFleetError>> {
let request_uri = "/deleteFleet";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteFleetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteFleetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_robot(
&self,
input: DeleteRobotRequest,
) -> Result<DeleteRobotResponse, RusotoError<DeleteRobotError>> {
let request_uri = "/deleteRobot";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteRobotResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteRobotError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_robot_application(
&self,
input: DeleteRobotApplicationRequest,
) -> Result<DeleteRobotApplicationResponse, RusotoError<DeleteRobotApplicationError>> {
let request_uri = "/deleteRobotApplication";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteRobotApplicationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteRobotApplicationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_simulation_application(
&self,
input: DeleteSimulationApplicationRequest,
) -> Result<DeleteSimulationApplicationResponse, RusotoError<DeleteSimulationApplicationError>>
{
let request_uri = "/deleteSimulationApplication";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteSimulationApplicationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteSimulationApplicationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_world_template(
&self,
input: DeleteWorldTemplateRequest,
) -> Result<DeleteWorldTemplateResponse, RusotoError<DeleteWorldTemplateError>> {
let request_uri = "/deleteWorldTemplate";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteWorldTemplateResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteWorldTemplateError::from_response(response))
}
}
#[allow(unused_mut)]
async fn deregister_robot(
&self,
input: DeregisterRobotRequest,
) -> Result<DeregisterRobotResponse, RusotoError<DeregisterRobotError>> {
let request_uri = "/deregisterRobot";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeregisterRobotResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeregisterRobotError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_deployment_job(
&self,
input: DescribeDeploymentJobRequest,
) -> Result<DescribeDeploymentJobResponse, RusotoError<DescribeDeploymentJobError>> {
let request_uri = "/describeDeploymentJob";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeDeploymentJobResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeDeploymentJobError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_fleet(
&self,
input: DescribeFleetRequest,
) -> Result<DescribeFleetResponse, RusotoError<DescribeFleetError>> {
let request_uri = "/describeFleet";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeFleetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeFleetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_robot(
&self,
input: DescribeRobotRequest,
) -> Result<DescribeRobotResponse, RusotoError<DescribeRobotError>> {
let request_uri = "/describeRobot";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeRobotResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeRobotError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_robot_application(
&self,
input: DescribeRobotApplicationRequest,
) -> Result<DescribeRobotApplicationResponse, RusotoError<DescribeRobotApplicationError>> {
let request_uri = "/describeRobotApplication";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeRobotApplicationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeRobotApplicationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_simulation_application(
&self,
input: DescribeSimulationApplicationRequest,
) -> Result<
DescribeSimulationApplicationResponse,
RusotoError<DescribeSimulationApplicationError>,
> {
let request_uri = "/describeSimulationApplication";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeSimulationApplicationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeSimulationApplicationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_simulation_job(
&self,
input: DescribeSimulationJobRequest,
) -> Result<DescribeSimulationJobResponse, RusotoError<DescribeSimulationJobError>> {
let request_uri = "/describeSimulationJob";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeSimulationJobResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeSimulationJobError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_simulation_job_batch(
&self,
input: DescribeSimulationJobBatchRequest,
) -> Result<DescribeSimulationJobBatchResponse, RusotoError<DescribeSimulationJobBatchError>>
{
let request_uri = "/describeSimulationJobBatch";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeSimulationJobBatchResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeSimulationJobBatchError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_world(
&self,
input: DescribeWorldRequest,
) -> Result<DescribeWorldResponse, RusotoError<DescribeWorldError>> {
let request_uri = "/describeWorld";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeWorldResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeWorldError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_world_export_job(
&self,
input: DescribeWorldExportJobRequest,
) -> Result<DescribeWorldExportJobResponse, RusotoError<DescribeWorldExportJobError>> {
let request_uri = "/describeWorldExportJob";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeWorldExportJobResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeWorldExportJobError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_world_generation_job(
&self,
input: DescribeWorldGenerationJobRequest,
) -> Result<DescribeWorldGenerationJobResponse, RusotoError<DescribeWorldGenerationJobError>>
{
let request_uri = "/describeWorldGenerationJob";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeWorldGenerationJobResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeWorldGenerationJobError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_world_template(
&self,
input: DescribeWorldTemplateRequest,
) -> Result<DescribeWorldTemplateResponse, RusotoError<DescribeWorldTemplateError>> {
let request_uri = "/describeWorldTemplate";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeWorldTemplateResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeWorldTemplateError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_world_template_body(
&self,
input: GetWorldTemplateBodyRequest,
) -> Result<GetWorldTemplateBodyResponse, RusotoError<GetWorldTemplateBodyError>> {
let request_uri = "/getWorldTemplateBody";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetWorldTemplateBodyResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetWorldTemplateBodyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_deployment_jobs(
&self,
input: ListDeploymentJobsRequest,
) -> Result<ListDeploymentJobsResponse, RusotoError<ListDeploymentJobsError>> {
let request_uri = "/listDeploymentJobs";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListDeploymentJobsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListDeploymentJobsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_fleets(
&self,
input: ListFleetsRequest,
) -> Result<ListFleetsResponse, RusotoError<ListFleetsError>> {
let request_uri = "/listFleets";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListFleetsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListFleetsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_robot_applications(
&self,
input: ListRobotApplicationsRequest,
) -> Result<ListRobotApplicationsResponse, RusotoError<ListRobotApplicationsError>> {
let request_uri = "/listRobotApplications";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListRobotApplicationsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListRobotApplicationsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_robots(
&self,
input: ListRobotsRequest,
) -> Result<ListRobotsResponse, RusotoError<ListRobotsError>> {
let request_uri = "/listRobots";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListRobotsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListRobotsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_simulation_applications(
&self,
input: ListSimulationApplicationsRequest,
) -> Result<ListSimulationApplicationsResponse, RusotoError<ListSimulationApplicationsError>>
{
let request_uri = "/listSimulationApplications";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListSimulationApplicationsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListSimulationApplicationsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_simulation_job_batches(
&self,
input: ListSimulationJobBatchesRequest,
) -> Result<ListSimulationJobBatchesResponse, RusotoError<ListSimulationJobBatchesError>> {
let request_uri = "/listSimulationJobBatches";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListSimulationJobBatchesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListSimulationJobBatchesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_simulation_jobs(
&self,
input: ListSimulationJobsRequest,
) -> Result<ListSimulationJobsResponse, RusotoError<ListSimulationJobsError>> {
let request_uri = "/listSimulationJobs";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListSimulationJobsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListSimulationJobsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("GET", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListTagsForResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListTagsForResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_world_export_jobs(
&self,
input: ListWorldExportJobsRequest,
) -> Result<ListWorldExportJobsResponse, RusotoError<ListWorldExportJobsError>> {
let request_uri = "/listWorldExportJobs";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListWorldExportJobsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListWorldExportJobsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_world_generation_jobs(
&self,
input: ListWorldGenerationJobsRequest,
) -> Result<ListWorldGenerationJobsResponse, RusotoError<ListWorldGenerationJobsError>> {
let request_uri = "/listWorldGenerationJobs";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListWorldGenerationJobsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListWorldGenerationJobsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_world_templates(
&self,
input: ListWorldTemplatesRequest,
) -> Result<ListWorldTemplatesResponse, RusotoError<ListWorldTemplatesError>> {
let request_uri = "/listWorldTemplates";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListWorldTemplatesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListWorldTemplatesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_worlds(
&self,
input: ListWorldsRequest,
) -> Result<ListWorldsResponse, RusotoError<ListWorldsError>> {
let request_uri = "/listWorlds";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListWorldsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListWorldsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn register_robot(
&self,
input: RegisterRobotRequest,
) -> Result<RegisterRobotResponse, RusotoError<RegisterRobotError>> {
let request_uri = "/registerRobot";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<RegisterRobotResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(RegisterRobotError::from_response(response))
}
}
#[allow(unused_mut)]
async fn restart_simulation_job(
&self,
input: RestartSimulationJobRequest,
) -> Result<RestartSimulationJobResponse, RusotoError<RestartSimulationJobError>> {
let request_uri = "/restartSimulationJob";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<RestartSimulationJobResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(RestartSimulationJobError::from_response(response))
}
}
#[allow(unused_mut)]
async fn start_simulation_job_batch(
&self,
input: StartSimulationJobBatchRequest,
) -> Result<StartSimulationJobBatchResponse, RusotoError<StartSimulationJobBatchError>> {
let request_uri = "/startSimulationJobBatch";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<StartSimulationJobBatchResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(StartSimulationJobBatchError::from_response(response))
}
}
#[allow(unused_mut)]
async fn sync_deployment_job(
&self,
input: SyncDeploymentJobRequest,
) -> Result<SyncDeploymentJobResponse, RusotoError<SyncDeploymentJobError>> {
let request_uri = "/syncDeploymentJob";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<SyncDeploymentJobResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(SyncDeploymentJobError::from_response(response))
}
}
#[allow(unused_mut)]
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<TagResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(TagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("DELETE", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
for item in input.tag_keys.iter() {
params.put("tagKeys", item);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UntagResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UntagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_robot_application(
&self,
input: UpdateRobotApplicationRequest,
) -> Result<UpdateRobotApplicationResponse, RusotoError<UpdateRobotApplicationError>> {
let request_uri = "/updateRobotApplication";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateRobotApplicationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateRobotApplicationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_simulation_application(
&self,
input: UpdateSimulationApplicationRequest,
) -> Result<UpdateSimulationApplicationResponse, RusotoError<UpdateSimulationApplicationError>>
{
let request_uri = "/updateSimulationApplication";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateSimulationApplicationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateSimulationApplicationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_world_template(
&self,
input: UpdateWorldTemplateRequest,
) -> Result<UpdateWorldTemplateResponse, RusotoError<UpdateWorldTemplateError>> {
let request_uri = "/updateWorldTemplate";
let mut request = SignedRequest::new("POST", "robomaker", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateWorldTemplateResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateWorldTemplateError::from_response(response))
}
}
}