use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::proto;
use rusoto_core::request::HttpResponse;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
impl IotThingsGraphClient {
fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
let mut request =
SignedRequest::new(http_method, "iotthingsgraph", &self.region, request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request
}
async fn sign_and_dispatch<E>(
&self,
request: SignedRequest,
from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
) -> Result<HttpResponse, RusotoError<E>> {
let mut response = self.client.sign_and_dispatch(request).await?;
if !response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
return Err(from_response(response));
}
Ok(response)
}
}
use serde_json;
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AssociateEntityToThingRequest {
#[serde(rename = "entityId")]
pub entity_id: String,
#[serde(rename = "namespaceVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub namespace_version: Option<i64>,
#[serde(rename = "thingName")]
pub thing_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssociateEntityToThingResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateFlowTemplateRequest {
#[serde(rename = "compatibleNamespaceVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compatible_namespace_version: Option<i64>,
#[serde(rename = "definition")]
pub definition: DefinitionDocument,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateFlowTemplateResponse {
#[serde(rename = "summary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub summary: Option<FlowTemplateSummary>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateSystemInstanceRequest {
#[serde(rename = "definition")]
pub definition: DefinitionDocument,
#[serde(rename = "flowActionsRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_actions_role_arn: Option<String>,
#[serde(rename = "greengrassGroupName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub greengrass_group_name: Option<String>,
#[serde(rename = "metricsConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metrics_configuration: Option<MetricsConfiguration>,
#[serde(rename = "s3BucketName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s_3_bucket_name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "target")]
pub target: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateSystemInstanceResponse {
#[serde(rename = "summary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub summary: Option<SystemInstanceSummary>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateSystemTemplateRequest {
#[serde(rename = "compatibleNamespaceVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compatible_namespace_version: Option<i64>,
#[serde(rename = "definition")]
pub definition: DefinitionDocument,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateSystemTemplateResponse {
#[serde(rename = "summary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub summary: Option<SystemTemplateSummary>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DefinitionDocument {
#[serde(rename = "language")]
pub language: String,
#[serde(rename = "text")]
pub text: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteFlowTemplateRequest {
#[serde(rename = "id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteFlowTemplateResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteNamespaceRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteNamespaceResponse {
#[serde(rename = "namespaceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub namespace_arn: Option<String>,
#[serde(rename = "namespaceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub namespace_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteSystemInstanceRequest {
#[serde(rename = "id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteSystemInstanceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteSystemTemplateRequest {
#[serde(rename = "id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteSystemTemplateResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DependencyRevision {
#[serde(rename = "id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "revisionNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_number: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeploySystemInstanceRequest {
#[serde(rename = "id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeploySystemInstanceResponse {
#[serde(rename = "greengrassDeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub greengrass_deployment_id: Option<String>,
#[serde(rename = "summary")]
pub summary: SystemInstanceSummary,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeprecateFlowTemplateRequest {
#[serde(rename = "id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeprecateFlowTemplateResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeprecateSystemTemplateRequest {
#[serde(rename = "id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeprecateSystemTemplateResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeNamespaceRequest {
#[serde(rename = "namespaceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub namespace_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeNamespaceResponse {
#[serde(rename = "namespaceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub namespace_arn: Option<String>,
#[serde(rename = "namespaceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub namespace_name: Option<String>,
#[serde(rename = "namespaceVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub namespace_version: Option<i64>,
#[serde(rename = "trackingNamespaceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tracking_namespace_name: Option<String>,
#[serde(rename = "trackingNamespaceVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tracking_namespace_version: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DissociateEntityFromThingRequest {
#[serde(rename = "entityType")]
pub entity_type: String,
#[serde(rename = "thingName")]
pub thing_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DissociateEntityFromThingResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EntityDescription {
#[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 = "definition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definition: Option<DefinitionDocument>,
#[serde(rename = "id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct EntityFilter {
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FlowExecutionMessage {
#[serde(rename = "eventType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_type: Option<String>,
#[serde(rename = "messageId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message_id: Option<String>,
#[serde(rename = "payload")]
#[serde(skip_serializing_if = "Option::is_none")]
pub payload: Option<String>,
#[serde(rename = "timestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timestamp: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FlowExecutionSummary {
#[serde(rename = "createdAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "flowExecutionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_execution_id: Option<String>,
#[serde(rename = "flowTemplateId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_template_id: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "systemInstanceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub system_instance_id: Option<String>,
#[serde(rename = "updatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub updated_at: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FlowTemplateDescription {
#[serde(rename = "definition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definition: Option<DefinitionDocument>,
#[serde(rename = "summary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub summary: Option<FlowTemplateSummary>,
#[serde(rename = "validatedNamespaceVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub validated_namespace_version: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct FlowTemplateFilter {
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "value")]
pub value: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FlowTemplateSummary {
#[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 = "id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "revisionNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_number: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetEntitiesRequest {
#[serde(rename = "ids")]
pub ids: Vec<String>,
#[serde(rename = "namespaceVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub namespace_version: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetEntitiesResponse {
#[serde(rename = "descriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub descriptions: Option<Vec<EntityDescription>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetFlowTemplateRequest {
#[serde(rename = "id")]
pub id: String,
#[serde(rename = "revisionNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_number: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetFlowTemplateResponse {
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<FlowTemplateDescription>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetFlowTemplateRevisionsRequest {
#[serde(rename = "id")]
pub id: String,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetFlowTemplateRevisionsResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "summaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub summaries: Option<Vec<FlowTemplateSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetNamespaceDeletionStatusRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetNamespaceDeletionStatusResponse {
#[serde(rename = "errorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "errorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "namespaceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub namespace_arn: Option<String>,
#[serde(rename = "namespaceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub namespace_name: 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 GetSystemInstanceRequest {
#[serde(rename = "id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetSystemInstanceResponse {
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<SystemInstanceDescription>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetSystemTemplateRequest {
#[serde(rename = "id")]
pub id: String,
#[serde(rename = "revisionNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_number: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetSystemTemplateResponse {
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<SystemTemplateDescription>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetSystemTemplateRevisionsRequest {
#[serde(rename = "id")]
pub id: String,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetSystemTemplateRevisionsResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "summaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub summaries: Option<Vec<SystemTemplateSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetUploadStatusRequest {
#[serde(rename = "uploadId")]
pub upload_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetUploadStatusResponse {
#[serde(rename = "createdDate")]
pub created_date: f64,
#[serde(rename = "failureReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_reason: Option<Vec<String>>,
#[serde(rename = "namespaceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub namespace_arn: Option<String>,
#[serde(rename = "namespaceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub namespace_name: Option<String>,
#[serde(rename = "namespaceVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub namespace_version: Option<i64>,
#[serde(rename = "uploadId")]
pub upload_id: String,
#[serde(rename = "uploadStatus")]
pub upload_status: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListFlowExecutionMessagesRequest {
#[serde(rename = "flowExecutionId")]
pub flow_execution_id: String,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListFlowExecutionMessagesResponse {
#[serde(rename = "messages")]
#[serde(skip_serializing_if = "Option::is_none")]
pub messages: Option<Vec<FlowExecutionMessage>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceRequest {
#[serde(rename = "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 = "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 = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MetricsConfiguration {
#[serde(rename = "cloudMetricEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_metric_enabled: Option<bool>,
#[serde(rename = "metricRuleRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metric_rule_role_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SearchEntitiesRequest {
#[serde(rename = "entityTypes")]
pub entity_types: Vec<String>,
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<EntityFilter>>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "namespaceVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub namespace_version: 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 SearchEntitiesResponse {
#[serde(rename = "descriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub descriptions: Option<Vec<EntityDescription>>,
#[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 SearchFlowExecutionsRequest {
#[serde(rename = "endTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_time: Option<f64>,
#[serde(rename = "flowExecutionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_execution_id: Option<String>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "startTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
#[serde(rename = "systemInstanceId")]
pub system_instance_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SearchFlowExecutionsResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "summaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub summaries: Option<Vec<FlowExecutionSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SearchFlowTemplatesRequest {
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<FlowTemplateFilter>>,
#[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 SearchFlowTemplatesResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "summaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub summaries: Option<Vec<FlowTemplateSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SearchSystemInstancesRequest {
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<SystemInstanceFilter>>,
#[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 SearchSystemInstancesResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "summaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub summaries: Option<Vec<SystemInstanceSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SearchSystemTemplatesRequest {
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<SystemTemplateFilter>>,
#[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 SearchSystemTemplatesResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "summaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub summaries: Option<Vec<SystemTemplateSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SearchThingsRequest {
#[serde(rename = "entityId")]
pub entity_id: String,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "namespaceVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub namespace_version: 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 SearchThingsResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "things")]
#[serde(skip_serializing_if = "Option::is_none")]
pub things: Option<Vec<Thing>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SystemInstanceDescription {
#[serde(rename = "definition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definition: Option<DefinitionDocument>,
#[serde(rename = "flowActionsRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub flow_actions_role_arn: Option<String>,
#[serde(rename = "metricsConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metrics_configuration: Option<MetricsConfiguration>,
#[serde(rename = "s3BucketName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s_3_bucket_name: Option<String>,
#[serde(rename = "summary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub summary: Option<SystemInstanceSummary>,
#[serde(rename = "validatedDependencyRevisions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub validated_dependency_revisions: Option<Vec<DependencyRevision>>,
#[serde(rename = "validatedNamespaceVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub validated_namespace_version: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SystemInstanceFilter {
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SystemInstanceSummary {
#[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 = "greengrassGroupName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub greengrass_group_name: Option<String>,
#[serde(rename = "greengrassGroupVersionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub greengrass_group_version_id: Option<String>,
#[serde(rename = "id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "target")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target: Option<String>,
#[serde(rename = "updatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub updated_at: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SystemTemplateDescription {
#[serde(rename = "definition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definition: Option<DefinitionDocument>,
#[serde(rename = "summary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub summary: Option<SystemTemplateSummary>,
#[serde(rename = "validatedNamespaceVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub validated_namespace_version: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SystemTemplateFilter {
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "value")]
pub value: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SystemTemplateSummary {
#[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 = "id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "revisionNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_number: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Tag {
#[serde(rename = "key")]
pub key: String,
#[serde(rename = "value")]
pub value: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "resourceArn")]
pub resource_arn: String,
#[serde(rename = "tags")]
pub tags: Vec<Tag>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TagResourceResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Thing {
#[serde(rename = "thingArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub thing_arn: Option<String>,
#[serde(rename = "thingName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub thing_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UndeploySystemInstanceRequest {
#[serde(rename = "id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UndeploySystemInstanceResponse {
#[serde(rename = "summary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub summary: Option<SystemInstanceSummary>,
}
#[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 UpdateFlowTemplateRequest {
#[serde(rename = "compatibleNamespaceVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compatible_namespace_version: Option<i64>,
#[serde(rename = "definition")]
pub definition: DefinitionDocument,
#[serde(rename = "id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateFlowTemplateResponse {
#[serde(rename = "summary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub summary: Option<FlowTemplateSummary>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateSystemTemplateRequest {
#[serde(rename = "compatibleNamespaceVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compatible_namespace_version: Option<i64>,
#[serde(rename = "definition")]
pub definition: DefinitionDocument,
#[serde(rename = "id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateSystemTemplateResponse {
#[serde(rename = "summary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub summary: Option<SystemTemplateSummary>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UploadEntityDefinitionsRequest {
#[serde(rename = "deprecateExistingEntities")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deprecate_existing_entities: Option<bool>,
#[serde(rename = "document")]
#[serde(skip_serializing_if = "Option::is_none")]
pub document: Option<DefinitionDocument>,
#[serde(rename = "syncWithPublicNamespace")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sync_with_public_namespace: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UploadEntityDefinitionsResponse {
#[serde(rename = "uploadId")]
pub upload_id: String,
}
#[derive(Debug, PartialEq)]
pub enum AssociateEntityToThingError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl AssociateEntityToThingError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AssociateEntityToThingError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(AssociateEntityToThingError::InternalFailure(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(AssociateEntityToThingError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AssociateEntityToThingError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(AssociateEntityToThingError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociateEntityToThingError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociateEntityToThingError::InternalFailure(ref cause) => write!(f, "{}", cause),
AssociateEntityToThingError::InvalidRequest(ref cause) => write!(f, "{}", cause),
AssociateEntityToThingError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AssociateEntityToThingError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AssociateEntityToThingError {}
#[derive(Debug, PartialEq)]
pub enum CreateFlowTemplateError {
InternalFailure(String),
InvalidRequest(String),
LimitExceeded(String),
ResourceAlreadyExists(String),
Throttling(String),
}
impl CreateFlowTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateFlowTemplateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(CreateFlowTemplateError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateFlowTemplateError::InvalidRequest(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateFlowTemplateError::LimitExceeded(err.msg))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(CreateFlowTemplateError::ResourceAlreadyExists(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(CreateFlowTemplateError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateFlowTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateFlowTemplateError::InternalFailure(ref cause) => write!(f, "{}", cause),
CreateFlowTemplateError::InvalidRequest(ref cause) => write!(f, "{}", cause),
CreateFlowTemplateError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateFlowTemplateError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateFlowTemplateError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateFlowTemplateError {}
#[derive(Debug, PartialEq)]
pub enum CreateSystemInstanceError {
InternalFailure(String),
InvalidRequest(String),
LimitExceeded(String),
ResourceAlreadyExists(String),
Throttling(String),
}
impl CreateSystemInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateSystemInstanceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(CreateSystemInstanceError::InternalFailure(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateSystemInstanceError::InvalidRequest(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateSystemInstanceError::LimitExceeded(err.msg))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(CreateSystemInstanceError::ResourceAlreadyExists(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(CreateSystemInstanceError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateSystemInstanceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateSystemInstanceError::InternalFailure(ref cause) => write!(f, "{}", cause),
CreateSystemInstanceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
CreateSystemInstanceError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateSystemInstanceError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateSystemInstanceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateSystemInstanceError {}
#[derive(Debug, PartialEq)]
pub enum CreateSystemTemplateError {
InternalFailure(String),
InvalidRequest(String),
ResourceAlreadyExists(String),
Throttling(String),
}
impl CreateSystemTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateSystemTemplateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(CreateSystemTemplateError::InternalFailure(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateSystemTemplateError::InvalidRequest(err.msg))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(CreateSystemTemplateError::ResourceAlreadyExists(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(CreateSystemTemplateError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateSystemTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateSystemTemplateError::InternalFailure(ref cause) => write!(f, "{}", cause),
CreateSystemTemplateError::InvalidRequest(ref cause) => write!(f, "{}", cause),
CreateSystemTemplateError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateSystemTemplateError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateSystemTemplateError {}
#[derive(Debug, PartialEq)]
pub enum DeleteFlowTemplateError {
InternalFailure(String),
InvalidRequest(String),
ResourceInUse(String),
Throttling(String),
}
impl DeleteFlowTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteFlowTemplateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(DeleteFlowTemplateError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteFlowTemplateError::InvalidRequest(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(DeleteFlowTemplateError::ResourceInUse(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DeleteFlowTemplateError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteFlowTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteFlowTemplateError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeleteFlowTemplateError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeleteFlowTemplateError::ResourceInUse(ref cause) => write!(f, "{}", cause),
DeleteFlowTemplateError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteFlowTemplateError {}
#[derive(Debug, PartialEq)]
pub enum DeleteNamespaceError {
InternalFailure(String),
Throttling(String),
}
impl DeleteNamespaceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteNamespaceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(DeleteNamespaceError::InternalFailure(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DeleteNamespaceError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteNamespaceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteNamespaceError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeleteNamespaceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteNamespaceError {}
#[derive(Debug, PartialEq)]
pub enum DeleteSystemInstanceError {
InternalFailure(String),
InvalidRequest(String),
ResourceInUse(String),
Throttling(String),
}
impl DeleteSystemInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteSystemInstanceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(DeleteSystemInstanceError::InternalFailure(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteSystemInstanceError::InvalidRequest(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(DeleteSystemInstanceError::ResourceInUse(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DeleteSystemInstanceError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteSystemInstanceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteSystemInstanceError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeleteSystemInstanceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeleteSystemInstanceError::ResourceInUse(ref cause) => write!(f, "{}", cause),
DeleteSystemInstanceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteSystemInstanceError {}
#[derive(Debug, PartialEq)]
pub enum DeleteSystemTemplateError {
InternalFailure(String),
InvalidRequest(String),
ResourceInUse(String),
Throttling(String),
}
impl DeleteSystemTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteSystemTemplateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(DeleteSystemTemplateError::InternalFailure(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteSystemTemplateError::InvalidRequest(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(DeleteSystemTemplateError::ResourceInUse(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DeleteSystemTemplateError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteSystemTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteSystemTemplateError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeleteSystemTemplateError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeleteSystemTemplateError::ResourceInUse(ref cause) => write!(f, "{}", cause),
DeleteSystemTemplateError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteSystemTemplateError {}
#[derive(Debug, PartialEq)]
pub enum DeploySystemInstanceError {
InternalFailure(String),
InvalidRequest(String),
ResourceInUse(String),
ResourceNotFound(String),
Throttling(String),
}
impl DeploySystemInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeploySystemInstanceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(DeploySystemInstanceError::InternalFailure(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(DeploySystemInstanceError::InvalidRequest(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(DeploySystemInstanceError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeploySystemInstanceError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(DeploySystemInstanceError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeploySystemInstanceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeploySystemInstanceError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeploySystemInstanceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeploySystemInstanceError::ResourceInUse(ref cause) => write!(f, "{}", cause),
DeploySystemInstanceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeploySystemInstanceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeploySystemInstanceError {}
#[derive(Debug, PartialEq)]
pub enum DeprecateFlowTemplateError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl DeprecateFlowTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeprecateFlowTemplateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(DeprecateFlowTemplateError::InternalFailure(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(DeprecateFlowTemplateError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeprecateFlowTemplateError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(DeprecateFlowTemplateError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeprecateFlowTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeprecateFlowTemplateError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeprecateFlowTemplateError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeprecateFlowTemplateError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeprecateFlowTemplateError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeprecateFlowTemplateError {}
#[derive(Debug, PartialEq)]
pub enum DeprecateSystemTemplateError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl DeprecateSystemTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeprecateSystemTemplateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(DeprecateSystemTemplateError::InternalFailure(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(DeprecateSystemTemplateError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeprecateSystemTemplateError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(DeprecateSystemTemplateError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeprecateSystemTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeprecateSystemTemplateError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeprecateSystemTemplateError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeprecateSystemTemplateError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeprecateSystemTemplateError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeprecateSystemTemplateError {}
#[derive(Debug, PartialEq)]
pub enum DescribeNamespaceError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl DescribeNamespaceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeNamespaceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(DescribeNamespaceError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DescribeNamespaceError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeNamespaceError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DescribeNamespaceError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeNamespaceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeNamespaceError::InternalFailure(ref cause) => write!(f, "{}", cause),
DescribeNamespaceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DescribeNamespaceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeNamespaceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeNamespaceError {}
#[derive(Debug, PartialEq)]
pub enum DissociateEntityFromThingError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl DissociateEntityFromThingError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DissociateEntityFromThingError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(DissociateEntityFromThingError::InternalFailure(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(DissociateEntityFromThingError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DissociateEntityFromThingError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(DissociateEntityFromThingError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DissociateEntityFromThingError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DissociateEntityFromThingError::InternalFailure(ref cause) => write!(f, "{}", cause),
DissociateEntityFromThingError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DissociateEntityFromThingError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DissociateEntityFromThingError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DissociateEntityFromThingError {}
#[derive(Debug, PartialEq)]
pub enum GetEntitiesError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl GetEntitiesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetEntitiesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(GetEntitiesError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetEntitiesError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetEntitiesError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(GetEntitiesError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetEntitiesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetEntitiesError::InternalFailure(ref cause) => write!(f, "{}", cause),
GetEntitiesError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetEntitiesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetEntitiesError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetEntitiesError {}
#[derive(Debug, PartialEq)]
pub enum GetFlowTemplateError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl GetFlowTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetFlowTemplateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(GetFlowTemplateError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetFlowTemplateError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetFlowTemplateError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(GetFlowTemplateError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetFlowTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetFlowTemplateError::InternalFailure(ref cause) => write!(f, "{}", cause),
GetFlowTemplateError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetFlowTemplateError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetFlowTemplateError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetFlowTemplateError {}
#[derive(Debug, PartialEq)]
pub enum GetFlowTemplateRevisionsError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl GetFlowTemplateRevisionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetFlowTemplateRevisionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(GetFlowTemplateRevisionsError::InternalFailure(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(GetFlowTemplateRevisionsError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetFlowTemplateRevisionsError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(GetFlowTemplateRevisionsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetFlowTemplateRevisionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetFlowTemplateRevisionsError::InternalFailure(ref cause) => write!(f, "{}", cause),
GetFlowTemplateRevisionsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetFlowTemplateRevisionsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetFlowTemplateRevisionsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetFlowTemplateRevisionsError {}
#[derive(Debug, PartialEq)]
pub enum GetNamespaceDeletionStatusError {
InternalFailure(String),
InvalidRequest(String),
Throttling(String),
}
impl GetNamespaceDeletionStatusError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetNamespaceDeletionStatusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(GetNamespaceDeletionStatusError::InternalFailure(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(GetNamespaceDeletionStatusError::InvalidRequest(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(GetNamespaceDeletionStatusError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetNamespaceDeletionStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetNamespaceDeletionStatusError::InternalFailure(ref cause) => write!(f, "{}", cause),
GetNamespaceDeletionStatusError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetNamespaceDeletionStatusError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetNamespaceDeletionStatusError {}
#[derive(Debug, PartialEq)]
pub enum GetSystemInstanceError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl GetSystemInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetSystemInstanceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(GetSystemInstanceError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetSystemInstanceError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetSystemInstanceError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(GetSystemInstanceError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetSystemInstanceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetSystemInstanceError::InternalFailure(ref cause) => write!(f, "{}", cause),
GetSystemInstanceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetSystemInstanceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetSystemInstanceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetSystemInstanceError {}
#[derive(Debug, PartialEq)]
pub enum GetSystemTemplateError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl GetSystemTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetSystemTemplateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(GetSystemTemplateError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetSystemTemplateError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetSystemTemplateError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(GetSystemTemplateError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetSystemTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetSystemTemplateError::InternalFailure(ref cause) => write!(f, "{}", cause),
GetSystemTemplateError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetSystemTemplateError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetSystemTemplateError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetSystemTemplateError {}
#[derive(Debug, PartialEq)]
pub enum GetSystemTemplateRevisionsError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl GetSystemTemplateRevisionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetSystemTemplateRevisionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(GetSystemTemplateRevisionsError::InternalFailure(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(GetSystemTemplateRevisionsError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetSystemTemplateRevisionsError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(GetSystemTemplateRevisionsError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetSystemTemplateRevisionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetSystemTemplateRevisionsError::InternalFailure(ref cause) => write!(f, "{}", cause),
GetSystemTemplateRevisionsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetSystemTemplateRevisionsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetSystemTemplateRevisionsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetSystemTemplateRevisionsError {}
#[derive(Debug, PartialEq)]
pub enum GetUploadStatusError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl GetUploadStatusError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetUploadStatusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(GetUploadStatusError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetUploadStatusError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetUploadStatusError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(GetUploadStatusError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetUploadStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetUploadStatusError::InternalFailure(ref cause) => write!(f, "{}", cause),
GetUploadStatusError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetUploadStatusError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetUploadStatusError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetUploadStatusError {}
#[derive(Debug, PartialEq)]
pub enum ListFlowExecutionMessagesError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl ListFlowExecutionMessagesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListFlowExecutionMessagesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(ListFlowExecutionMessagesError::InternalFailure(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(ListFlowExecutionMessagesError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListFlowExecutionMessagesError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(ListFlowExecutionMessagesError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListFlowExecutionMessagesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListFlowExecutionMessagesError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListFlowExecutionMessagesError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListFlowExecutionMessagesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListFlowExecutionMessagesError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListFlowExecutionMessagesError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
InternalFailure(String),
InvalidRequest(String),
ResourceAlreadyExists(String),
Throttling(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(ListTagsForResourceError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidRequest(err.msg))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(ListTagsForResourceError::ResourceAlreadyExists(
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::InternalFailure(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum SearchEntitiesError {
InternalFailure(String),
InvalidRequest(String),
Throttling(String),
}
impl SearchEntitiesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SearchEntitiesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(SearchEntitiesError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(SearchEntitiesError::InvalidRequest(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(SearchEntitiesError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SearchEntitiesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SearchEntitiesError::InternalFailure(ref cause) => write!(f, "{}", cause),
SearchEntitiesError::InvalidRequest(ref cause) => write!(f, "{}", cause),
SearchEntitiesError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SearchEntitiesError {}
#[derive(Debug, PartialEq)]
pub enum SearchFlowExecutionsError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl SearchFlowExecutionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SearchFlowExecutionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(SearchFlowExecutionsError::InternalFailure(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(SearchFlowExecutionsError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(SearchFlowExecutionsError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(SearchFlowExecutionsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SearchFlowExecutionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SearchFlowExecutionsError::InternalFailure(ref cause) => write!(f, "{}", cause),
SearchFlowExecutionsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
SearchFlowExecutionsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
SearchFlowExecutionsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SearchFlowExecutionsError {}
#[derive(Debug, PartialEq)]
pub enum SearchFlowTemplatesError {
InternalFailure(String),
InvalidRequest(String),
Throttling(String),
}
impl SearchFlowTemplatesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SearchFlowTemplatesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(SearchFlowTemplatesError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(SearchFlowTemplatesError::InvalidRequest(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(SearchFlowTemplatesError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SearchFlowTemplatesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SearchFlowTemplatesError::InternalFailure(ref cause) => write!(f, "{}", cause),
SearchFlowTemplatesError::InvalidRequest(ref cause) => write!(f, "{}", cause),
SearchFlowTemplatesError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SearchFlowTemplatesError {}
#[derive(Debug, PartialEq)]
pub enum SearchSystemInstancesError {
InternalFailure(String),
InvalidRequest(String),
Throttling(String),
}
impl SearchSystemInstancesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SearchSystemInstancesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(SearchSystemInstancesError::InternalFailure(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(SearchSystemInstancesError::InvalidRequest(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(SearchSystemInstancesError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SearchSystemInstancesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SearchSystemInstancesError::InternalFailure(ref cause) => write!(f, "{}", cause),
SearchSystemInstancesError::InvalidRequest(ref cause) => write!(f, "{}", cause),
SearchSystemInstancesError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SearchSystemInstancesError {}
#[derive(Debug, PartialEq)]
pub enum SearchSystemTemplatesError {
InternalFailure(String),
InvalidRequest(String),
Throttling(String),
}
impl SearchSystemTemplatesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SearchSystemTemplatesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(SearchSystemTemplatesError::InternalFailure(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(SearchSystemTemplatesError::InvalidRequest(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(SearchSystemTemplatesError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SearchSystemTemplatesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SearchSystemTemplatesError::InternalFailure(ref cause) => write!(f, "{}", cause),
SearchSystemTemplatesError::InvalidRequest(ref cause) => write!(f, "{}", cause),
SearchSystemTemplatesError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SearchSystemTemplatesError {}
#[derive(Debug, PartialEq)]
pub enum SearchThingsError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl SearchThingsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SearchThingsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(SearchThingsError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(SearchThingsError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(SearchThingsError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(SearchThingsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SearchThingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SearchThingsError::InternalFailure(ref cause) => write!(f, "{}", cause),
SearchThingsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
SearchThingsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
SearchThingsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SearchThingsError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
InternalFailure(String),
InvalidRequest(String),
ResourceAlreadyExists(String),
Throttling(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(TagResourceError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(TagResourceError::InvalidRequest(err.msg))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(TagResourceError::ResourceAlreadyExists(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::InternalFailure(ref cause) => write!(f, "{}", cause),
TagResourceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
TagResourceError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
TagResourceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UndeploySystemInstanceError {
InternalFailure(String),
InvalidRequest(String),
ResourceInUse(String),
ResourceNotFound(String),
Throttling(String),
}
impl UndeploySystemInstanceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UndeploySystemInstanceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(UndeploySystemInstanceError::InternalFailure(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(UndeploySystemInstanceError::InvalidRequest(
err.msg,
))
}
"ResourceInUseException" => {
return RusotoError::Service(UndeploySystemInstanceError::ResourceInUse(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UndeploySystemInstanceError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(UndeploySystemInstanceError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UndeploySystemInstanceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UndeploySystemInstanceError::InternalFailure(ref cause) => write!(f, "{}", cause),
UndeploySystemInstanceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UndeploySystemInstanceError::ResourceInUse(ref cause) => write!(f, "{}", cause),
UndeploySystemInstanceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UndeploySystemInstanceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UndeploySystemInstanceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
InternalFailure(String),
InvalidRequest(String),
ResourceAlreadyExists(String),
Throttling(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(UntagResourceError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(UntagResourceError::InvalidRequest(err.msg))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(UntagResourceError::ResourceAlreadyExists(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::InternalFailure(ref cause) => write!(f, "{}", cause),
UntagResourceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UntagResourceError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
UntagResourceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateFlowTemplateError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl UpdateFlowTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateFlowTemplateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(UpdateFlowTemplateError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(UpdateFlowTemplateError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateFlowTemplateError::ResourceNotFound(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(UpdateFlowTemplateError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateFlowTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateFlowTemplateError::InternalFailure(ref cause) => write!(f, "{}", cause),
UpdateFlowTemplateError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UpdateFlowTemplateError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateFlowTemplateError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateFlowTemplateError {}
#[derive(Debug, PartialEq)]
pub enum UpdateSystemTemplateError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
Throttling(String),
}
impl UpdateSystemTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateSystemTemplateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(UpdateSystemTemplateError::InternalFailure(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(UpdateSystemTemplateError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateSystemTemplateError::ResourceNotFound(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(UpdateSystemTemplateError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateSystemTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateSystemTemplateError::InternalFailure(ref cause) => write!(f, "{}", cause),
UpdateSystemTemplateError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UpdateSystemTemplateError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateSystemTemplateError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateSystemTemplateError {}
#[derive(Debug, PartialEq)]
pub enum UploadEntityDefinitionsError {
InternalFailure(String),
InvalidRequest(String),
Throttling(String),
}
impl UploadEntityDefinitionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UploadEntityDefinitionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(UploadEntityDefinitionsError::InternalFailure(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(UploadEntityDefinitionsError::InvalidRequest(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(UploadEntityDefinitionsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UploadEntityDefinitionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UploadEntityDefinitionsError::InternalFailure(ref cause) => write!(f, "{}", cause),
UploadEntityDefinitionsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UploadEntityDefinitionsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UploadEntityDefinitionsError {}
#[async_trait]
pub trait IotThingsGraph {
async fn associate_entity_to_thing(
&self,
input: AssociateEntityToThingRequest,
) -> Result<AssociateEntityToThingResponse, RusotoError<AssociateEntityToThingError>>;
async fn create_flow_template(
&self,
input: CreateFlowTemplateRequest,
) -> Result<CreateFlowTemplateResponse, RusotoError<CreateFlowTemplateError>>;
async fn create_system_instance(
&self,
input: CreateSystemInstanceRequest,
) -> Result<CreateSystemInstanceResponse, RusotoError<CreateSystemInstanceError>>;
async fn create_system_template(
&self,
input: CreateSystemTemplateRequest,
) -> Result<CreateSystemTemplateResponse, RusotoError<CreateSystemTemplateError>>;
async fn delete_flow_template(
&self,
input: DeleteFlowTemplateRequest,
) -> Result<DeleteFlowTemplateResponse, RusotoError<DeleteFlowTemplateError>>;
async fn delete_namespace(
&self,
) -> Result<DeleteNamespaceResponse, RusotoError<DeleteNamespaceError>>;
async fn delete_system_instance(
&self,
input: DeleteSystemInstanceRequest,
) -> Result<DeleteSystemInstanceResponse, RusotoError<DeleteSystemInstanceError>>;
async fn delete_system_template(
&self,
input: DeleteSystemTemplateRequest,
) -> Result<DeleteSystemTemplateResponse, RusotoError<DeleteSystemTemplateError>>;
async fn deploy_system_instance(
&self,
input: DeploySystemInstanceRequest,
) -> Result<DeploySystemInstanceResponse, RusotoError<DeploySystemInstanceError>>;
async fn deprecate_flow_template(
&self,
input: DeprecateFlowTemplateRequest,
) -> Result<DeprecateFlowTemplateResponse, RusotoError<DeprecateFlowTemplateError>>;
async fn deprecate_system_template(
&self,
input: DeprecateSystemTemplateRequest,
) -> Result<DeprecateSystemTemplateResponse, RusotoError<DeprecateSystemTemplateError>>;
async fn describe_namespace(
&self,
input: DescribeNamespaceRequest,
) -> Result<DescribeNamespaceResponse, RusotoError<DescribeNamespaceError>>;
async fn dissociate_entity_from_thing(
&self,
input: DissociateEntityFromThingRequest,
) -> Result<DissociateEntityFromThingResponse, RusotoError<DissociateEntityFromThingError>>;
async fn get_entities(
&self,
input: GetEntitiesRequest,
) -> Result<GetEntitiesResponse, RusotoError<GetEntitiesError>>;
async fn get_flow_template(
&self,
input: GetFlowTemplateRequest,
) -> Result<GetFlowTemplateResponse, RusotoError<GetFlowTemplateError>>;
async fn get_flow_template_revisions(
&self,
input: GetFlowTemplateRevisionsRequest,
) -> Result<GetFlowTemplateRevisionsResponse, RusotoError<GetFlowTemplateRevisionsError>>;
async fn get_namespace_deletion_status(
&self,
) -> Result<GetNamespaceDeletionStatusResponse, RusotoError<GetNamespaceDeletionStatusError>>;
async fn get_system_instance(
&self,
input: GetSystemInstanceRequest,
) -> Result<GetSystemInstanceResponse, RusotoError<GetSystemInstanceError>>;
async fn get_system_template(
&self,
input: GetSystemTemplateRequest,
) -> Result<GetSystemTemplateResponse, RusotoError<GetSystemTemplateError>>;
async fn get_system_template_revisions(
&self,
input: GetSystemTemplateRevisionsRequest,
) -> Result<GetSystemTemplateRevisionsResponse, RusotoError<GetSystemTemplateRevisionsError>>;
async fn get_upload_status(
&self,
input: GetUploadStatusRequest,
) -> Result<GetUploadStatusResponse, RusotoError<GetUploadStatusError>>;
async fn list_flow_execution_messages(
&self,
input: ListFlowExecutionMessagesRequest,
) -> Result<ListFlowExecutionMessagesResponse, RusotoError<ListFlowExecutionMessagesError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
async fn search_entities(
&self,
input: SearchEntitiesRequest,
) -> Result<SearchEntitiesResponse, RusotoError<SearchEntitiesError>>;
async fn search_flow_executions(
&self,
input: SearchFlowExecutionsRequest,
) -> Result<SearchFlowExecutionsResponse, RusotoError<SearchFlowExecutionsError>>;
async fn search_flow_templates(
&self,
input: SearchFlowTemplatesRequest,
) -> Result<SearchFlowTemplatesResponse, RusotoError<SearchFlowTemplatesError>>;
async fn search_system_instances(
&self,
input: SearchSystemInstancesRequest,
) -> Result<SearchSystemInstancesResponse, RusotoError<SearchSystemInstancesError>>;
async fn search_system_templates(
&self,
input: SearchSystemTemplatesRequest,
) -> Result<SearchSystemTemplatesResponse, RusotoError<SearchSystemTemplatesError>>;
async fn search_things(
&self,
input: SearchThingsRequest,
) -> Result<SearchThingsResponse, RusotoError<SearchThingsError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>>;
async fn undeploy_system_instance(
&self,
input: UndeploySystemInstanceRequest,
) -> Result<UndeploySystemInstanceResponse, RusotoError<UndeploySystemInstanceError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>>;
async fn update_flow_template(
&self,
input: UpdateFlowTemplateRequest,
) -> Result<UpdateFlowTemplateResponse, RusotoError<UpdateFlowTemplateError>>;
async fn update_system_template(
&self,
input: UpdateSystemTemplateRequest,
) -> Result<UpdateSystemTemplateResponse, RusotoError<UpdateSystemTemplateError>>;
async fn upload_entity_definitions(
&self,
input: UploadEntityDefinitionsRequest,
) -> Result<UploadEntityDefinitionsResponse, RusotoError<UploadEntityDefinitionsError>>;
}
#[derive(Clone)]
pub struct IotThingsGraphClient {
client: Client,
region: region::Region,
}
impl IotThingsGraphClient {
pub fn new(region: region::Region) -> IotThingsGraphClient {
IotThingsGraphClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> IotThingsGraphClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
IotThingsGraphClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> IotThingsGraphClient {
IotThingsGraphClient { client, region }
}
}
#[async_trait]
impl IotThingsGraph for IotThingsGraphClient {
async fn associate_entity_to_thing(
&self,
input: AssociateEntityToThingRequest,
) -> Result<AssociateEntityToThingResponse, RusotoError<AssociateEntityToThingError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.AssociateEntityToThing",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AssociateEntityToThingError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AssociateEntityToThingResponse, _>()
}
async fn create_flow_template(
&self,
input: CreateFlowTemplateRequest,
) -> Result<CreateFlowTemplateResponse, RusotoError<CreateFlowTemplateError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.CreateFlowTemplate",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateFlowTemplateError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateFlowTemplateResponse, _>()
}
async fn create_system_instance(
&self,
input: CreateSystemInstanceRequest,
) -> Result<CreateSystemInstanceResponse, RusotoError<CreateSystemInstanceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.CreateSystemInstance",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateSystemInstanceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateSystemInstanceResponse, _>()
}
async fn create_system_template(
&self,
input: CreateSystemTemplateRequest,
) -> Result<CreateSystemTemplateResponse, RusotoError<CreateSystemTemplateError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.CreateSystemTemplate",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateSystemTemplateError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateSystemTemplateResponse, _>()
}
async fn delete_flow_template(
&self,
input: DeleteFlowTemplateRequest,
) -> Result<DeleteFlowTemplateResponse, RusotoError<DeleteFlowTemplateError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.DeleteFlowTemplate",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteFlowTemplateError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteFlowTemplateResponse, _>()
}
async fn delete_namespace(
&self,
) -> Result<DeleteNamespaceResponse, RusotoError<DeleteNamespaceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.DeleteNamespace",
);
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(request, DeleteNamespaceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteNamespaceResponse, _>()
}
async fn delete_system_instance(
&self,
input: DeleteSystemInstanceRequest,
) -> Result<DeleteSystemInstanceResponse, RusotoError<DeleteSystemInstanceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.DeleteSystemInstance",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteSystemInstanceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteSystemInstanceResponse, _>()
}
async fn delete_system_template(
&self,
input: DeleteSystemTemplateRequest,
) -> Result<DeleteSystemTemplateResponse, RusotoError<DeleteSystemTemplateError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.DeleteSystemTemplate",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteSystemTemplateError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteSystemTemplateResponse, _>()
}
async fn deploy_system_instance(
&self,
input: DeploySystemInstanceRequest,
) -> Result<DeploySystemInstanceResponse, RusotoError<DeploySystemInstanceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.DeploySystemInstance",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeploySystemInstanceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeploySystemInstanceResponse, _>()
}
async fn deprecate_flow_template(
&self,
input: DeprecateFlowTemplateRequest,
) -> Result<DeprecateFlowTemplateResponse, RusotoError<DeprecateFlowTemplateError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.DeprecateFlowTemplate",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeprecateFlowTemplateError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeprecateFlowTemplateResponse, _>()
}
async fn deprecate_system_template(
&self,
input: DeprecateSystemTemplateRequest,
) -> Result<DeprecateSystemTemplateResponse, RusotoError<DeprecateSystemTemplateError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.DeprecateSystemTemplate",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeprecateSystemTemplateError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeprecateSystemTemplateResponse, _>()
}
async fn describe_namespace(
&self,
input: DescribeNamespaceRequest,
) -> Result<DescribeNamespaceResponse, RusotoError<DescribeNamespaceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.DescribeNamespace",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeNamespaceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeNamespaceResponse, _>()
}
async fn dissociate_entity_from_thing(
&self,
input: DissociateEntityFromThingRequest,
) -> Result<DissociateEntityFromThingResponse, RusotoError<DissociateEntityFromThingError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.DissociateEntityFromThing",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DissociateEntityFromThingError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DissociateEntityFromThingResponse, _>()
}
async fn get_entities(
&self,
input: GetEntitiesRequest,
) -> Result<GetEntitiesResponse, RusotoError<GetEntitiesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "IotThingsGraphFrontEndService.GetEntities");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetEntitiesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetEntitiesResponse, _>()
}
async fn get_flow_template(
&self,
input: GetFlowTemplateRequest,
) -> Result<GetFlowTemplateResponse, RusotoError<GetFlowTemplateError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.GetFlowTemplate",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetFlowTemplateError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetFlowTemplateResponse, _>()
}
async fn get_flow_template_revisions(
&self,
input: GetFlowTemplateRevisionsRequest,
) -> Result<GetFlowTemplateRevisionsResponse, RusotoError<GetFlowTemplateRevisionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.GetFlowTemplateRevisions",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetFlowTemplateRevisionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetFlowTemplateRevisionsResponse, _>()
}
async fn get_namespace_deletion_status(
&self,
) -> Result<GetNamespaceDeletionStatusResponse, RusotoError<GetNamespaceDeletionStatusError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.GetNamespaceDeletionStatus",
);
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(request, GetNamespaceDeletionStatusError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetNamespaceDeletionStatusResponse, _>()
}
async fn get_system_instance(
&self,
input: GetSystemInstanceRequest,
) -> Result<GetSystemInstanceResponse, RusotoError<GetSystemInstanceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.GetSystemInstance",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetSystemInstanceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetSystemInstanceResponse, _>()
}
async fn get_system_template(
&self,
input: GetSystemTemplateRequest,
) -> Result<GetSystemTemplateResponse, RusotoError<GetSystemTemplateError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.GetSystemTemplate",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetSystemTemplateError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetSystemTemplateResponse, _>()
}
async fn get_system_template_revisions(
&self,
input: GetSystemTemplateRevisionsRequest,
) -> Result<GetSystemTemplateRevisionsResponse, RusotoError<GetSystemTemplateRevisionsError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.GetSystemTemplateRevisions",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetSystemTemplateRevisionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetSystemTemplateRevisionsResponse, _>()
}
async fn get_upload_status(
&self,
input: GetUploadStatusRequest,
) -> Result<GetUploadStatusResponse, RusotoError<GetUploadStatusError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.GetUploadStatus",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetUploadStatusError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetUploadStatusResponse, _>()
}
async fn list_flow_execution_messages(
&self,
input: ListFlowExecutionMessagesRequest,
) -> Result<ListFlowExecutionMessagesResponse, RusotoError<ListFlowExecutionMessagesError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.ListFlowExecutionMessages",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListFlowExecutionMessagesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListFlowExecutionMessagesResponse, _>()
}
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.ListTagsForResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListTagsForResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListTagsForResourceResponse, _>()
}
async fn search_entities(
&self,
input: SearchEntitiesRequest,
) -> Result<SearchEntitiesResponse, RusotoError<SearchEntitiesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.SearchEntities",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, SearchEntitiesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<SearchEntitiesResponse, _>()
}
async fn search_flow_executions(
&self,
input: SearchFlowExecutionsRequest,
) -> Result<SearchFlowExecutionsResponse, RusotoError<SearchFlowExecutionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.SearchFlowExecutions",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, SearchFlowExecutionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<SearchFlowExecutionsResponse, _>()
}
async fn search_flow_templates(
&self,
input: SearchFlowTemplatesRequest,
) -> Result<SearchFlowTemplatesResponse, RusotoError<SearchFlowTemplatesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.SearchFlowTemplates",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, SearchFlowTemplatesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<SearchFlowTemplatesResponse, _>()
}
async fn search_system_instances(
&self,
input: SearchSystemInstancesRequest,
) -> Result<SearchSystemInstancesResponse, RusotoError<SearchSystemInstancesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.SearchSystemInstances",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, SearchSystemInstancesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<SearchSystemInstancesResponse, _>()
}
async fn search_system_templates(
&self,
input: SearchSystemTemplatesRequest,
) -> Result<SearchSystemTemplatesResponse, RusotoError<SearchSystemTemplatesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.SearchSystemTemplates",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, SearchSystemTemplatesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<SearchSystemTemplatesResponse, _>()
}
async fn search_things(
&self,
input: SearchThingsRequest,
) -> Result<SearchThingsResponse, RusotoError<SearchThingsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "IotThingsGraphFrontEndService.SearchThings");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, SearchThingsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<SearchThingsResponse, _>()
}
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "IotThingsGraphFrontEndService.TagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, TagResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<TagResourceResponse, _>()
}
async fn undeploy_system_instance(
&self,
input: UndeploySystemInstanceRequest,
) -> Result<UndeploySystemInstanceResponse, RusotoError<UndeploySystemInstanceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.UndeploySystemInstance",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UndeploySystemInstanceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UndeploySystemInstanceResponse, _>()
}
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.UntagResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UntagResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UntagResourceResponse, _>()
}
async fn update_flow_template(
&self,
input: UpdateFlowTemplateRequest,
) -> Result<UpdateFlowTemplateResponse, RusotoError<UpdateFlowTemplateError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.UpdateFlowTemplate",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateFlowTemplateError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateFlowTemplateResponse, _>()
}
async fn update_system_template(
&self,
input: UpdateSystemTemplateRequest,
) -> Result<UpdateSystemTemplateResponse, RusotoError<UpdateSystemTemplateError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.UpdateSystemTemplate",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateSystemTemplateError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateSystemTemplateResponse, _>()
}
async fn upload_entity_definitions(
&self,
input: UploadEntityDefinitionsRequest,
) -> Result<UploadEntityDefinitionsResponse, RusotoError<UploadEntityDefinitionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"IotThingsGraphFrontEndService.UploadEntityDefinitions",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UploadEntityDefinitionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UploadEntityDefinitionsResponse, _>()
}
}