use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::param::{Params, ServiceParams};
use rusoto_core::proto;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
use serde_json;
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AssociateRoleToGroupRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
#[serde(rename = "RoleArn")]
pub role_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssociateRoleToGroupResponse {
#[serde(rename = "AssociatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub associated_at: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AssociateServiceRoleToAccountRequest {
#[serde(rename = "RoleArn")]
pub role_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssociateServiceRoleToAccountResponse {
#[serde(rename = "AssociatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub associated_at: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BulkDeployment {
#[serde(rename = "BulkDeploymentArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bulk_deployment_arn: Option<String>,
#[serde(rename = "BulkDeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bulk_deployment_id: Option<String>,
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BulkDeploymentMetrics {
#[serde(rename = "InvalidInputRecords")]
#[serde(skip_serializing_if = "Option::is_none")]
pub invalid_input_records: Option<i64>,
#[serde(rename = "RecordsProcessed")]
#[serde(skip_serializing_if = "Option::is_none")]
pub records_processed: Option<i64>,
#[serde(rename = "RetryAttempts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retry_attempts: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BulkDeploymentResult {
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
#[serde(rename = "DeploymentArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_arn: Option<String>,
#[serde(rename = "DeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "DeploymentStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_status: Option<String>,
#[serde(rename = "DeploymentType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_type: Option<String>,
#[serde(rename = "ErrorDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_details: Option<Vec<ErrorDetail>>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "GroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ConnectivityInfo {
#[serde(rename = "HostAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub host_address: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Metadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata: Option<String>,
#[serde(rename = "PortNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port_number: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Connector {
#[serde(rename = "ConnectorArn")]
pub connector_arn: String,
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "Parameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameters: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ConnectorDefinitionVersion {
#[serde(rename = "Connectors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connectors: Option<Vec<Connector>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Core {
#[serde(rename = "CertificateArn")]
pub certificate_arn: String,
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "SyncShadow")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sync_shadow: Option<bool>,
#[serde(rename = "ThingArn")]
pub thing_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CoreDefinitionVersion {
#[serde(rename = "Cores")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cores: Option<Vec<Core>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateConnectorDefinitionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "InitialVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub initial_version: Option<ConnectorDefinitionVersion>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateConnectorDefinitionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateConnectorDefinitionVersionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "ConnectorDefinitionId")]
pub connector_definition_id: String,
#[serde(rename = "Connectors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connectors: Option<Vec<Connector>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateConnectorDefinitionVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateCoreDefinitionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "InitialVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub initial_version: Option<CoreDefinitionVersion>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateCoreDefinitionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateCoreDefinitionVersionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "CoreDefinitionId")]
pub core_definition_id: String,
#[serde(rename = "Cores")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cores: Option<Vec<Core>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateCoreDefinitionVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDeploymentRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "DeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "DeploymentType")]
pub deployment_type: String,
#[serde(rename = "GroupId")]
pub group_id: String,
#[serde(rename = "GroupVersionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_version_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDeploymentResponse {
#[serde(rename = "DeploymentArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_arn: Option<String>,
#[serde(rename = "DeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDeviceDefinitionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "InitialVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub initial_version: Option<DeviceDefinitionVersion>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDeviceDefinitionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDeviceDefinitionVersionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "DeviceDefinitionId")]
pub device_definition_id: String,
#[serde(rename = "Devices")]
#[serde(skip_serializing_if = "Option::is_none")]
pub devices: Option<Vec<Device>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDeviceDefinitionVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateFunctionDefinitionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "InitialVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub initial_version: Option<FunctionDefinitionVersion>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateFunctionDefinitionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateFunctionDefinitionVersionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "DefaultConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_config: Option<FunctionDefaultConfig>,
#[serde(rename = "FunctionDefinitionId")]
pub function_definition_id: String,
#[serde(rename = "Functions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub functions: Option<Vec<Function>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateFunctionDefinitionVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateGroupCertificateAuthorityRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "GroupId")]
pub group_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateGroupCertificateAuthorityResponse {
#[serde(rename = "GroupCertificateAuthorityArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_certificate_authority_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateGroupRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "InitialVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub initial_version: Option<GroupVersion>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateGroupResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateGroupVersionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "ConnectorDefinitionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connector_definition_version_arn: Option<String>,
#[serde(rename = "CoreDefinitionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub core_definition_version_arn: Option<String>,
#[serde(rename = "DeviceDefinitionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_definition_version_arn: Option<String>,
#[serde(rename = "FunctionDefinitionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_definition_version_arn: Option<String>,
#[serde(rename = "GroupId")]
pub group_id: String,
#[serde(rename = "LoggerDefinitionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub logger_definition_version_arn: Option<String>,
#[serde(rename = "ResourceDefinitionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_definition_version_arn: Option<String>,
#[serde(rename = "SubscriptionDefinitionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subscription_definition_version_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateGroupVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateLoggerDefinitionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "InitialVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub initial_version: Option<LoggerDefinitionVersion>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateLoggerDefinitionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateLoggerDefinitionVersionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "LoggerDefinitionId")]
pub logger_definition_id: String,
#[serde(rename = "Loggers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub loggers: Option<Vec<Logger>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateLoggerDefinitionVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateResourceDefinitionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "InitialVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub initial_version: Option<ResourceDefinitionVersion>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateResourceDefinitionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateResourceDefinitionVersionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "ResourceDefinitionId")]
pub resource_definition_id: String,
#[serde(rename = "Resources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resources: Option<Vec<Resource>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateResourceDefinitionVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateSoftwareUpdateJobRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "S3UrlSignerRole")]
pub s3_url_signer_role: String,
#[serde(rename = "SoftwareToUpdate")]
pub software_to_update: String,
#[serde(rename = "UpdateAgentLogLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub update_agent_log_level: Option<String>,
#[serde(rename = "UpdateTargets")]
pub update_targets: Vec<String>,
#[serde(rename = "UpdateTargetsArchitecture")]
pub update_targets_architecture: String,
#[serde(rename = "UpdateTargetsOperatingSystem")]
pub update_targets_operating_system: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateSoftwareUpdateJobResponse {
#[serde(rename = "IotJobArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iot_job_arn: Option<String>,
#[serde(rename = "IotJobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iot_job_id: Option<String>,
#[serde(rename = "PlatformSoftwareVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub platform_software_version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateSubscriptionDefinitionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "InitialVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub initial_version: Option<SubscriptionDefinitionVersion>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateSubscriptionDefinitionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateSubscriptionDefinitionVersionRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "SubscriptionDefinitionId")]
pub subscription_definition_id: String,
#[serde(rename = "Subscriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subscriptions: Option<Vec<Subscription>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateSubscriptionDefinitionVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DefinitionInformation {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteConnectorDefinitionRequest {
#[serde(rename = "ConnectorDefinitionId")]
pub connector_definition_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteConnectorDefinitionResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteCoreDefinitionRequest {
#[serde(rename = "CoreDefinitionId")]
pub core_definition_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteCoreDefinitionResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDeviceDefinitionRequest {
#[serde(rename = "DeviceDefinitionId")]
pub device_definition_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteDeviceDefinitionResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteFunctionDefinitionRequest {
#[serde(rename = "FunctionDefinitionId")]
pub function_definition_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteFunctionDefinitionResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteGroupRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteGroupResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteLoggerDefinitionRequest {
#[serde(rename = "LoggerDefinitionId")]
pub logger_definition_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteLoggerDefinitionResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteResourceDefinitionRequest {
#[serde(rename = "ResourceDefinitionId")]
pub resource_definition_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteResourceDefinitionResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteSubscriptionDefinitionRequest {
#[serde(rename = "SubscriptionDefinitionId")]
pub subscription_definition_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteSubscriptionDefinitionResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Deployment {
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
#[serde(rename = "DeploymentArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_arn: Option<String>,
#[serde(rename = "DeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "DeploymentType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_type: Option<String>,
#[serde(rename = "GroupArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Device {
#[serde(rename = "CertificateArn")]
pub certificate_arn: String,
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "SyncShadow")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sync_shadow: Option<bool>,
#[serde(rename = "ThingArn")]
pub thing_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DeviceDefinitionVersion {
#[serde(rename = "Devices")]
#[serde(skip_serializing_if = "Option::is_none")]
pub devices: Option<Vec<Device>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisassociateRoleFromGroupRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisassociateRoleFromGroupResponse {
#[serde(rename = "DisassociatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disassociated_at: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisassociateServiceRoleFromAccountRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisassociateServiceRoleFromAccountResponse {
#[serde(rename = "DisassociatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disassociated_at: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ErrorDetail {
#[serde(rename = "DetailedErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub detailed_error_code: Option<String>,
#[serde(rename = "DetailedErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub detailed_error_message: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Function {
#[serde(rename = "FunctionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_arn: Option<String>,
#[serde(rename = "FunctionConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_configuration: Option<FunctionConfiguration>,
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct FunctionConfiguration {
#[serde(rename = "EncodingType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encoding_type: Option<String>,
#[serde(rename = "Environment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub environment: Option<FunctionConfigurationEnvironment>,
#[serde(rename = "ExecArgs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub exec_args: Option<String>,
#[serde(rename = "Executable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub executable: Option<String>,
#[serde(rename = "MemorySize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub memory_size: Option<i64>,
#[serde(rename = "Pinned")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pinned: Option<bool>,
#[serde(rename = "Timeout")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timeout: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct FunctionConfigurationEnvironment {
#[serde(rename = "AccessSysfs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_sysfs: Option<bool>,
#[serde(rename = "Execution")]
#[serde(skip_serializing_if = "Option::is_none")]
pub execution: Option<FunctionExecutionConfig>,
#[serde(rename = "ResourceAccessPolicies")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_access_policies: Option<Vec<ResourceAccessPolicy>>,
#[serde(rename = "Variables")]
#[serde(skip_serializing_if = "Option::is_none")]
pub variables: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct FunctionDefaultConfig {
#[serde(rename = "Execution")]
#[serde(skip_serializing_if = "Option::is_none")]
pub execution: Option<FunctionDefaultExecutionConfig>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct FunctionDefaultExecutionConfig {
#[serde(rename = "IsolationMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub isolation_mode: Option<String>,
#[serde(rename = "RunAs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub run_as: Option<FunctionRunAsConfig>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct FunctionDefinitionVersion {
#[serde(rename = "DefaultConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_config: Option<FunctionDefaultConfig>,
#[serde(rename = "Functions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub functions: Option<Vec<Function>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct FunctionExecutionConfig {
#[serde(rename = "IsolationMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub isolation_mode: Option<String>,
#[serde(rename = "RunAs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub run_as: Option<FunctionRunAsConfig>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct FunctionRunAsConfig {
#[serde(rename = "Gid")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gid: Option<i64>,
#[serde(rename = "Uid")]
#[serde(skip_serializing_if = "Option::is_none")]
pub uid: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetAssociatedRoleRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetAssociatedRoleResponse {
#[serde(rename = "AssociatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub associated_at: Option<String>,
#[serde(rename = "RoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetBulkDeploymentStatusRequest {
#[serde(rename = "BulkDeploymentId")]
pub bulk_deployment_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetBulkDeploymentStatusResponse {
#[serde(rename = "BulkDeploymentMetrics")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bulk_deployment_metrics: Option<BulkDeploymentMetrics>,
#[serde(rename = "BulkDeploymentStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bulk_deployment_status: Option<String>,
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
#[serde(rename = "ErrorDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_details: Option<Vec<ErrorDetail>>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetConnectivityInfoRequest {
#[serde(rename = "ThingName")]
pub thing_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetConnectivityInfoResponse {
#[serde(rename = "ConnectivityInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connectivity_info: Option<Vec<ConnectivityInfo>>,
#[serde(rename = "Message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetConnectorDefinitionRequest {
#[serde(rename = "ConnectorDefinitionId")]
pub connector_definition_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetConnectorDefinitionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetConnectorDefinitionVersionRequest {
#[serde(rename = "ConnectorDefinitionId")]
pub connector_definition_id: String,
#[serde(rename = "ConnectorDefinitionVersionId")]
pub connector_definition_version_id: String,
#[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 GetConnectorDefinitionVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Definition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definition: Option<ConnectorDefinitionVersion>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetCoreDefinitionRequest {
#[serde(rename = "CoreDefinitionId")]
pub core_definition_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetCoreDefinitionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetCoreDefinitionVersionRequest {
#[serde(rename = "CoreDefinitionId")]
pub core_definition_id: String,
#[serde(rename = "CoreDefinitionVersionId")]
pub core_definition_version_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetCoreDefinitionVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Definition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definition: Option<CoreDefinitionVersion>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDeploymentStatusRequest {
#[serde(rename = "DeploymentId")]
pub deployment_id: String,
#[serde(rename = "GroupId")]
pub group_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDeploymentStatusResponse {
#[serde(rename = "DeploymentStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_status: Option<String>,
#[serde(rename = "DeploymentType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_type: Option<String>,
#[serde(rename = "ErrorDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_details: Option<Vec<ErrorDetail>>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "UpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub updated_at: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDeviceDefinitionRequest {
#[serde(rename = "DeviceDefinitionId")]
pub device_definition_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDeviceDefinitionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDeviceDefinitionVersionRequest {
#[serde(rename = "DeviceDefinitionId")]
pub device_definition_id: String,
#[serde(rename = "DeviceDefinitionVersionId")]
pub device_definition_version_id: String,
#[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 GetDeviceDefinitionVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Definition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definition: Option<DeviceDefinitionVersion>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetFunctionDefinitionRequest {
#[serde(rename = "FunctionDefinitionId")]
pub function_definition_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetFunctionDefinitionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetFunctionDefinitionVersionRequest {
#[serde(rename = "FunctionDefinitionId")]
pub function_definition_id: String,
#[serde(rename = "FunctionDefinitionVersionId")]
pub function_definition_version_id: String,
#[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 GetFunctionDefinitionVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Definition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definition: Option<FunctionDefinitionVersion>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetGroupCertificateAuthorityRequest {
#[serde(rename = "CertificateAuthorityId")]
pub certificate_authority_id: String,
#[serde(rename = "GroupId")]
pub group_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetGroupCertificateAuthorityResponse {
#[serde(rename = "GroupCertificateAuthorityArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_certificate_authority_arn: Option<String>,
#[serde(rename = "GroupCertificateAuthorityId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_certificate_authority_id: Option<String>,
#[serde(rename = "PemEncodedCertificate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pem_encoded_certificate: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetGroupCertificateConfigurationRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetGroupCertificateConfigurationResponse {
#[serde(rename = "CertificateAuthorityExpiryInMilliseconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_authority_expiry_in_milliseconds: Option<String>,
#[serde(rename = "CertificateExpiryInMilliseconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_expiry_in_milliseconds: Option<String>,
#[serde(rename = "GroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetGroupRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetGroupResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetGroupVersionRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
#[serde(rename = "GroupVersionId")]
pub group_version_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetGroupVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Definition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definition: Option<GroupVersion>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetLoggerDefinitionRequest {
#[serde(rename = "LoggerDefinitionId")]
pub logger_definition_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetLoggerDefinitionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetLoggerDefinitionVersionRequest {
#[serde(rename = "LoggerDefinitionId")]
pub logger_definition_id: String,
#[serde(rename = "LoggerDefinitionVersionId")]
pub logger_definition_version_id: String,
#[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 GetLoggerDefinitionVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Definition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definition: Option<LoggerDefinitionVersion>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetResourceDefinitionRequest {
#[serde(rename = "ResourceDefinitionId")]
pub resource_definition_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetResourceDefinitionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetResourceDefinitionVersionRequest {
#[serde(rename = "ResourceDefinitionId")]
pub resource_definition_id: String,
#[serde(rename = "ResourceDefinitionVersionId")]
pub resource_definition_version_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetResourceDefinitionVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Definition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definition: Option<ResourceDefinitionVersion>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetServiceRoleForAccountRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetServiceRoleForAccountResponse {
#[serde(rename = "AssociatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub associated_at: Option<String>,
#[serde(rename = "RoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetSubscriptionDefinitionRequest {
#[serde(rename = "SubscriptionDefinitionId")]
pub subscription_definition_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetSubscriptionDefinitionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetSubscriptionDefinitionVersionRequest {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "SubscriptionDefinitionId")]
pub subscription_definition_id: String,
#[serde(rename = "SubscriptionDefinitionVersionId")]
pub subscription_definition_version_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetSubscriptionDefinitionVersionResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Definition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definition: Option<SubscriptionDefinitionVersion>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetThingRuntimeConfigurationRequest {
#[serde(rename = "ThingName")]
pub thing_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetThingRuntimeConfigurationResponse {
#[serde(rename = "RuntimeConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub runtime_configuration: Option<RuntimeConfiguration>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GroupCertificateAuthorityProperties {
#[serde(rename = "GroupCertificateAuthorityArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_certificate_authority_arn: Option<String>,
#[serde(rename = "GroupCertificateAuthorityId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_certificate_authority_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GroupInformation {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "LastUpdatedTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_timestamp: Option<String>,
#[serde(rename = "LatestVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version: Option<String>,
#[serde(rename = "LatestVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_version_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct GroupOwnerSetting {
#[serde(rename = "AutoAddGroupOwner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_add_group_owner: Option<bool>,
#[serde(rename = "GroupOwner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_owner: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct GroupVersion {
#[serde(rename = "ConnectorDefinitionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connector_definition_version_arn: Option<String>,
#[serde(rename = "CoreDefinitionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub core_definition_version_arn: Option<String>,
#[serde(rename = "DeviceDefinitionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_definition_version_arn: Option<String>,
#[serde(rename = "FunctionDefinitionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_definition_version_arn: Option<String>,
#[serde(rename = "LoggerDefinitionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub logger_definition_version_arn: Option<String>,
#[serde(rename = "ResourceDefinitionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_definition_version_arn: Option<String>,
#[serde(rename = "SubscriptionDefinitionVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subscription_definition_version_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListBulkDeploymentDetailedReportsRequest {
#[serde(rename = "BulkDeploymentId")]
pub bulk_deployment_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[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 ListBulkDeploymentDetailedReportsResponse {
#[serde(rename = "Deployments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployments: Option<Vec<BulkDeploymentResult>>,
#[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 ListBulkDeploymentsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[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 ListBulkDeploymentsResponse {
#[serde(rename = "BulkDeployments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bulk_deployments: Option<Vec<BulkDeployment>>,
#[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 ListConnectorDefinitionVersionsRequest {
#[serde(rename = "ConnectorDefinitionId")]
pub connector_definition_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[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 ListConnectorDefinitionVersionsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Versions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub versions: Option<Vec<VersionInformation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListConnectorDefinitionsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[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 ListConnectorDefinitionsResponse {
#[serde(rename = "Definitions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definitions: Option<Vec<DefinitionInformation>>,
#[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 ListCoreDefinitionVersionsRequest {
#[serde(rename = "CoreDefinitionId")]
pub core_definition_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[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 ListCoreDefinitionVersionsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Versions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub versions: Option<Vec<VersionInformation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListCoreDefinitionsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[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 ListCoreDefinitionsResponse {
#[serde(rename = "Definitions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definitions: Option<Vec<DefinitionInformation>>,
#[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 ListDeploymentsRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[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 ListDeploymentsResponse {
#[serde(rename = "Deployments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployments: Option<Vec<Deployment>>,
#[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 ListDeviceDefinitionVersionsRequest {
#[serde(rename = "DeviceDefinitionId")]
pub device_definition_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[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 ListDeviceDefinitionVersionsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Versions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub versions: Option<Vec<VersionInformation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDeviceDefinitionsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[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 ListDeviceDefinitionsResponse {
#[serde(rename = "Definitions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definitions: Option<Vec<DefinitionInformation>>,
#[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 ListFunctionDefinitionVersionsRequest {
#[serde(rename = "FunctionDefinitionId")]
pub function_definition_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[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 ListFunctionDefinitionVersionsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Versions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub versions: Option<Vec<VersionInformation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListFunctionDefinitionsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[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 ListFunctionDefinitionsResponse {
#[serde(rename = "Definitions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definitions: Option<Vec<DefinitionInformation>>,
#[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 ListGroupCertificateAuthoritiesRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListGroupCertificateAuthoritiesResponse {
#[serde(rename = "GroupCertificateAuthorities")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_certificate_authorities: Option<Vec<GroupCertificateAuthorityProperties>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListGroupVersionsRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[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 ListGroupVersionsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Versions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub versions: Option<Vec<VersionInformation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListGroupsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[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 ListGroupsResponse {
#[serde(rename = "Groups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub groups: Option<Vec<GroupInformation>>,
#[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 ListLoggerDefinitionVersionsRequest {
#[serde(rename = "LoggerDefinitionId")]
pub logger_definition_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[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 ListLoggerDefinitionVersionsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Versions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub versions: Option<Vec<VersionInformation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListLoggerDefinitionsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[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 ListLoggerDefinitionsResponse {
#[serde(rename = "Definitions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definitions: Option<Vec<DefinitionInformation>>,
#[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 ListResourceDefinitionVersionsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ResourceDefinitionId")]
pub resource_definition_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListResourceDefinitionVersionsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Versions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub versions: Option<Vec<VersionInformation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListResourceDefinitionsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[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 ListResourceDefinitionsResponse {
#[serde(rename = "Definitions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definitions: Option<Vec<DefinitionInformation>>,
#[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 ListSubscriptionDefinitionVersionsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "SubscriptionDefinitionId")]
pub subscription_definition_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListSubscriptionDefinitionVersionsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Versions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub versions: Option<Vec<VersionInformation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListSubscriptionDefinitionsRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[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 ListSubscriptionDefinitionsResponse {
#[serde(rename = "Definitions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definitions: Option<Vec<DefinitionInformation>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceResponse {
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct LocalDeviceResourceData {
#[serde(rename = "GroupOwnerSetting")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_owner_setting: Option<GroupOwnerSetting>,
#[serde(rename = "SourcePath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_path: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct LocalVolumeResourceData {
#[serde(rename = "DestinationPath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_path: Option<String>,
#[serde(rename = "GroupOwnerSetting")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_owner_setting: Option<GroupOwnerSetting>,
#[serde(rename = "SourcePath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_path: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Logger {
#[serde(rename = "Component")]
pub component: String,
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "Level")]
pub level: String,
#[serde(rename = "Space")]
#[serde(skip_serializing_if = "Option::is_none")]
pub space: Option<i64>,
#[serde(rename = "Type")]
pub type_: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct LoggerDefinitionVersion {
#[serde(rename = "Loggers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub loggers: Option<Vec<Logger>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ResetDeploymentsRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "Force")]
#[serde(skip_serializing_if = "Option::is_none")]
pub force: Option<bool>,
#[serde(rename = "GroupId")]
pub group_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResetDeploymentsResponse {
#[serde(rename = "DeploymentArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_arn: Option<String>,
#[serde(rename = "DeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Resource {
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "ResourceDataContainer")]
pub resource_data_container: ResourceDataContainer,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ResourceAccessPolicy {
#[serde(rename = "Permission")]
#[serde(skip_serializing_if = "Option::is_none")]
pub permission: Option<String>,
#[serde(rename = "ResourceId")]
pub resource_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ResourceDataContainer {
#[serde(rename = "LocalDeviceResourceData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub local_device_resource_data: Option<LocalDeviceResourceData>,
#[serde(rename = "LocalVolumeResourceData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub local_volume_resource_data: Option<LocalVolumeResourceData>,
#[serde(rename = "S3MachineLearningModelResourceData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_machine_learning_model_resource_data: Option<S3MachineLearningModelResourceData>,
#[serde(rename = "SageMakerMachineLearningModelResourceData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sage_maker_machine_learning_model_resource_data:
Option<SageMakerMachineLearningModelResourceData>,
#[serde(rename = "SecretsManagerSecretResourceData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub secrets_manager_secret_resource_data: Option<SecretsManagerSecretResourceData>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ResourceDefinitionVersion {
#[serde(rename = "Resources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resources: Option<Vec<Resource>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ResourceDownloadOwnerSetting {
#[serde(rename = "GroupOwner")]
pub group_owner: String,
#[serde(rename = "GroupPermission")]
pub group_permission: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RuntimeConfiguration {
#[serde(rename = "TelemetryConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub telemetry_configuration: Option<TelemetryConfiguration>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct S3MachineLearningModelResourceData {
#[serde(rename = "DestinationPath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_path: Option<String>,
#[serde(rename = "OwnerSetting")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner_setting: Option<ResourceDownloadOwnerSetting>,
#[serde(rename = "S3Uri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_uri: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SageMakerMachineLearningModelResourceData {
#[serde(rename = "DestinationPath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_path: Option<String>,
#[serde(rename = "OwnerSetting")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner_setting: Option<ResourceDownloadOwnerSetting>,
#[serde(rename = "SageMakerJobArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sage_maker_job_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SecretsManagerSecretResourceData {
#[serde(rename = "ARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "AdditionalStagingLabelsToDownload")]
#[serde(skip_serializing_if = "Option::is_none")]
pub additional_staging_labels_to_download: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartBulkDeploymentRequest {
#[serde(rename = "AmznClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amzn_client_token: Option<String>,
#[serde(rename = "ExecutionRoleArn")]
pub execution_role_arn: String,
#[serde(rename = "InputFileUri")]
pub input_file_uri: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartBulkDeploymentResponse {
#[serde(rename = "BulkDeploymentArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bulk_deployment_arn: Option<String>,
#[serde(rename = "BulkDeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bulk_deployment_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopBulkDeploymentRequest {
#[serde(rename = "BulkDeploymentId")]
pub bulk_deployment_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StopBulkDeploymentResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Subscription {
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "Source")]
pub source: String,
#[serde(rename = "Subject")]
pub subject: String,
#[serde(rename = "Target")]
pub target: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SubscriptionDefinitionVersion {
#[serde(rename = "Subscriptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subscriptions: Option<Vec<Subscription>>,
}
#[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")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TelemetryConfiguration {
#[serde(rename = "ConfigurationSyncStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_sync_status: Option<String>,
#[serde(rename = "Telemetry")]
pub telemetry: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TelemetryConfigurationUpdate {
#[serde(rename = "Telemetry")]
pub telemetry: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateConnectivityInfoRequest {
#[serde(rename = "ConnectivityInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connectivity_info: Option<Vec<ConnectivityInfo>>,
#[serde(rename = "ThingName")]
pub thing_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateConnectivityInfoResponse {
#[serde(rename = "Message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateConnectorDefinitionRequest {
#[serde(rename = "ConnectorDefinitionId")]
pub connector_definition_id: String,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateConnectorDefinitionResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateCoreDefinitionRequest {
#[serde(rename = "CoreDefinitionId")]
pub core_definition_id: String,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateCoreDefinitionResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateDeviceDefinitionRequest {
#[serde(rename = "DeviceDefinitionId")]
pub device_definition_id: String,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateDeviceDefinitionResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateFunctionDefinitionRequest {
#[serde(rename = "FunctionDefinitionId")]
pub function_definition_id: String,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateFunctionDefinitionResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateGroupCertificateConfigurationRequest {
#[serde(rename = "CertificateExpiryInMilliseconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_expiry_in_milliseconds: Option<String>,
#[serde(rename = "GroupId")]
pub group_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateGroupCertificateConfigurationResponse {
#[serde(rename = "CertificateAuthorityExpiryInMilliseconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_authority_expiry_in_milliseconds: Option<String>,
#[serde(rename = "CertificateExpiryInMilliseconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_expiry_in_milliseconds: Option<String>,
#[serde(rename = "GroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateGroupRequest {
#[serde(rename = "GroupId")]
pub group_id: String,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateGroupResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateLoggerDefinitionRequest {
#[serde(rename = "LoggerDefinitionId")]
pub logger_definition_id: String,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateLoggerDefinitionResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateResourceDefinitionRequest {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ResourceDefinitionId")]
pub resource_definition_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateResourceDefinitionResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateSubscriptionDefinitionRequest {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "SubscriptionDefinitionId")]
pub subscription_definition_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateSubscriptionDefinitionResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateThingRuntimeConfigurationRequest {
#[serde(rename = "TelemetryConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub telemetry_configuration: Option<TelemetryConfigurationUpdate>,
#[serde(rename = "ThingName")]
pub thing_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateThingRuntimeConfigurationResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct VersionInformation {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreationTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_timestamp: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum AssociateRoleToGroupError {
BadRequest(String),
InternalServerError(String),
}
impl AssociateRoleToGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AssociateRoleToGroupError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(AssociateRoleToGroupError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(AssociateRoleToGroupError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociateRoleToGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociateRoleToGroupError::BadRequest(ref cause) => write!(f, "{}", cause),
AssociateRoleToGroupError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AssociateRoleToGroupError {}
#[derive(Debug, PartialEq)]
pub enum AssociateServiceRoleToAccountError {
BadRequest(String),
InternalServerError(String),
}
impl AssociateServiceRoleToAccountError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AssociateServiceRoleToAccountError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(AssociateServiceRoleToAccountError::BadRequest(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
AssociateServiceRoleToAccountError::InternalServerError(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociateServiceRoleToAccountError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociateServiceRoleToAccountError::BadRequest(ref cause) => write!(f, "{}", cause),
AssociateServiceRoleToAccountError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AssociateServiceRoleToAccountError {}
#[derive(Debug, PartialEq)]
pub enum CreateConnectorDefinitionError {
BadRequest(String),
}
impl CreateConnectorDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateConnectorDefinitionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateConnectorDefinitionError::BadRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateConnectorDefinitionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateConnectorDefinitionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateConnectorDefinitionError {}
#[derive(Debug, PartialEq)]
pub enum CreateConnectorDefinitionVersionError {
BadRequest(String),
}
impl CreateConnectorDefinitionVersionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateConnectorDefinitionVersionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateConnectorDefinitionVersionError::BadRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateConnectorDefinitionVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateConnectorDefinitionVersionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateConnectorDefinitionVersionError {}
#[derive(Debug, PartialEq)]
pub enum CreateCoreDefinitionError {
BadRequest(String),
}
impl CreateCoreDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateCoreDefinitionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateCoreDefinitionError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateCoreDefinitionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateCoreDefinitionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateCoreDefinitionError {}
#[derive(Debug, PartialEq)]
pub enum CreateCoreDefinitionVersionError {
BadRequest(String),
}
impl CreateCoreDefinitionVersionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateCoreDefinitionVersionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateCoreDefinitionVersionError::BadRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateCoreDefinitionVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateCoreDefinitionVersionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateCoreDefinitionVersionError {}
#[derive(Debug, PartialEq)]
pub enum CreateDeploymentError {
BadRequest(String),
}
impl CreateDeploymentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDeploymentError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateDeploymentError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDeploymentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDeploymentError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDeploymentError {}
#[derive(Debug, PartialEq)]
pub enum CreateDeviceDefinitionError {
BadRequest(String),
}
impl CreateDeviceDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDeviceDefinitionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateDeviceDefinitionError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDeviceDefinitionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDeviceDefinitionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDeviceDefinitionError {}
#[derive(Debug, PartialEq)]
pub enum CreateDeviceDefinitionVersionError {
BadRequest(String),
}
impl CreateDeviceDefinitionVersionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateDeviceDefinitionVersionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateDeviceDefinitionVersionError::BadRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDeviceDefinitionVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDeviceDefinitionVersionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDeviceDefinitionVersionError {}
#[derive(Debug, PartialEq)]
pub enum CreateFunctionDefinitionError {
BadRequest(String),
}
impl CreateFunctionDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateFunctionDefinitionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateFunctionDefinitionError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateFunctionDefinitionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateFunctionDefinitionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateFunctionDefinitionError {}
#[derive(Debug, PartialEq)]
pub enum CreateFunctionDefinitionVersionError {
BadRequest(String),
}
impl CreateFunctionDefinitionVersionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateFunctionDefinitionVersionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateFunctionDefinitionVersionError::BadRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateFunctionDefinitionVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateFunctionDefinitionVersionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateFunctionDefinitionVersionError {}
#[derive(Debug, PartialEq)]
pub enum CreateGroupError {
BadRequest(String),
}
impl CreateGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateGroupError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateGroupError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateGroupError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateGroupError {}
#[derive(Debug, PartialEq)]
pub enum CreateGroupCertificateAuthorityError {
BadRequest(String),
InternalServerError(String),
}
impl CreateGroupCertificateAuthorityError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateGroupCertificateAuthorityError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateGroupCertificateAuthorityError::BadRequest(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
CreateGroupCertificateAuthorityError::InternalServerError(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateGroupCertificateAuthorityError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateGroupCertificateAuthorityError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateGroupCertificateAuthorityError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateGroupCertificateAuthorityError {}
#[derive(Debug, PartialEq)]
pub enum CreateGroupVersionError {
BadRequest(String),
}
impl CreateGroupVersionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateGroupVersionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateGroupVersionError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateGroupVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateGroupVersionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateGroupVersionError {}
#[derive(Debug, PartialEq)]
pub enum CreateLoggerDefinitionError {
BadRequest(String),
}
impl CreateLoggerDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateLoggerDefinitionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateLoggerDefinitionError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateLoggerDefinitionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateLoggerDefinitionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateLoggerDefinitionError {}
#[derive(Debug, PartialEq)]
pub enum CreateLoggerDefinitionVersionError {
BadRequest(String),
}
impl CreateLoggerDefinitionVersionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateLoggerDefinitionVersionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateLoggerDefinitionVersionError::BadRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateLoggerDefinitionVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateLoggerDefinitionVersionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateLoggerDefinitionVersionError {}
#[derive(Debug, PartialEq)]
pub enum CreateResourceDefinitionError {
BadRequest(String),
}
impl CreateResourceDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateResourceDefinitionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateResourceDefinitionError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateResourceDefinitionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateResourceDefinitionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateResourceDefinitionError {}
#[derive(Debug, PartialEq)]
pub enum CreateResourceDefinitionVersionError {
BadRequest(String),
}
impl CreateResourceDefinitionVersionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateResourceDefinitionVersionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateResourceDefinitionVersionError::BadRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateResourceDefinitionVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateResourceDefinitionVersionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateResourceDefinitionVersionError {}
#[derive(Debug, PartialEq)]
pub enum CreateSoftwareUpdateJobError {
BadRequest(String),
InternalServerError(String),
}
impl CreateSoftwareUpdateJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateSoftwareUpdateJobError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateSoftwareUpdateJobError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(CreateSoftwareUpdateJobError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateSoftwareUpdateJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateSoftwareUpdateJobError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateSoftwareUpdateJobError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateSoftwareUpdateJobError {}
#[derive(Debug, PartialEq)]
pub enum CreateSubscriptionDefinitionError {
BadRequest(String),
}
impl CreateSubscriptionDefinitionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateSubscriptionDefinitionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateSubscriptionDefinitionError::BadRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateSubscriptionDefinitionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateSubscriptionDefinitionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateSubscriptionDefinitionError {}
#[derive(Debug, PartialEq)]
pub enum CreateSubscriptionDefinitionVersionError {
BadRequest(String),
}
impl CreateSubscriptionDefinitionVersionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateSubscriptionDefinitionVersionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(
CreateSubscriptionDefinitionVersionError::BadRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateSubscriptionDefinitionVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateSubscriptionDefinitionVersionError::BadRequest(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateSubscriptionDefinitionVersionError {}
#[derive(Debug, PartialEq)]
pub enum DeleteConnectorDefinitionError {
BadRequest(String),
}
impl DeleteConnectorDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteConnectorDefinitionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteConnectorDefinitionError::BadRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteConnectorDefinitionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteConnectorDefinitionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteConnectorDefinitionError {}
#[derive(Debug, PartialEq)]
pub enum DeleteCoreDefinitionError {
BadRequest(String),
}
impl DeleteCoreDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteCoreDefinitionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteCoreDefinitionError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteCoreDefinitionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteCoreDefinitionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteCoreDefinitionError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDeviceDefinitionError {
BadRequest(String),
}
impl DeleteDeviceDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDeviceDefinitionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteDeviceDefinitionError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDeviceDefinitionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDeviceDefinitionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDeviceDefinitionError {}
#[derive(Debug, PartialEq)]
pub enum DeleteFunctionDefinitionError {
BadRequest(String),
}
impl DeleteFunctionDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteFunctionDefinitionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteFunctionDefinitionError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteFunctionDefinitionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteFunctionDefinitionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteFunctionDefinitionError {}
#[derive(Debug, PartialEq)]
pub enum DeleteGroupError {
BadRequest(String),
}
impl DeleteGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteGroupError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteGroupError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteGroupError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteGroupError {}
#[derive(Debug, PartialEq)]
pub enum DeleteLoggerDefinitionError {
BadRequest(String),
}
impl DeleteLoggerDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteLoggerDefinitionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteLoggerDefinitionError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteLoggerDefinitionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteLoggerDefinitionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteLoggerDefinitionError {}
#[derive(Debug, PartialEq)]
pub enum DeleteResourceDefinitionError {
BadRequest(String),
}
impl DeleteResourceDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteResourceDefinitionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteResourceDefinitionError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteResourceDefinitionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteResourceDefinitionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteResourceDefinitionError {}
#[derive(Debug, PartialEq)]
pub enum DeleteSubscriptionDefinitionError {
BadRequest(String),
}
impl DeleteSubscriptionDefinitionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteSubscriptionDefinitionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteSubscriptionDefinitionError::BadRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteSubscriptionDefinitionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteSubscriptionDefinitionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteSubscriptionDefinitionError {}
#[derive(Debug, PartialEq)]
pub enum DisassociateRoleFromGroupError {
BadRequest(String),
InternalServerError(String),
}
impl DisassociateRoleFromGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DisassociateRoleFromGroupError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DisassociateRoleFromGroupError::BadRequest(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
DisassociateRoleFromGroupError::InternalServerError(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisassociateRoleFromGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisassociateRoleFromGroupError::BadRequest(ref cause) => write!(f, "{}", cause),
DisassociateRoleFromGroupError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DisassociateRoleFromGroupError {}
#[derive(Debug, PartialEq)]
pub enum DisassociateServiceRoleFromAccountError {
InternalServerError(String),
}
impl DisassociateServiceRoleFromAccountError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisassociateServiceRoleFromAccountError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(
DisassociateServiceRoleFromAccountError::InternalServerError(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisassociateServiceRoleFromAccountError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisassociateServiceRoleFromAccountError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DisassociateServiceRoleFromAccountError {}
#[derive(Debug, PartialEq)]
pub enum GetAssociatedRoleError {
BadRequest(String),
InternalServerError(String),
}
impl GetAssociatedRoleError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetAssociatedRoleError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetAssociatedRoleError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(GetAssociatedRoleError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetAssociatedRoleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetAssociatedRoleError::BadRequest(ref cause) => write!(f, "{}", cause),
GetAssociatedRoleError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetAssociatedRoleError {}
#[derive(Debug, PartialEq)]
pub enum GetBulkDeploymentStatusError {
BadRequest(String),
}
impl GetBulkDeploymentStatusError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetBulkDeploymentStatusError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetBulkDeploymentStatusError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetBulkDeploymentStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetBulkDeploymentStatusError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetBulkDeploymentStatusError {}
#[derive(Debug, PartialEq)]
pub enum GetConnectivityInfoError {
BadRequest(String),
InternalServerError(String),
}
impl GetConnectivityInfoError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetConnectivityInfoError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetConnectivityInfoError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(GetConnectivityInfoError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetConnectivityInfoError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetConnectivityInfoError::BadRequest(ref cause) => write!(f, "{}", cause),
GetConnectivityInfoError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetConnectivityInfoError {}
#[derive(Debug, PartialEq)]
pub enum GetConnectorDefinitionError {
BadRequest(String),
}
impl GetConnectorDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetConnectorDefinitionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetConnectorDefinitionError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetConnectorDefinitionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetConnectorDefinitionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetConnectorDefinitionError {}
#[derive(Debug, PartialEq)]
pub enum GetConnectorDefinitionVersionError {
BadRequest(String),
}
impl GetConnectorDefinitionVersionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetConnectorDefinitionVersionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetConnectorDefinitionVersionError::BadRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetConnectorDefinitionVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetConnectorDefinitionVersionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetConnectorDefinitionVersionError {}
#[derive(Debug, PartialEq)]
pub enum GetCoreDefinitionError {
BadRequest(String),
}
impl GetCoreDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetCoreDefinitionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetCoreDefinitionError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetCoreDefinitionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetCoreDefinitionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetCoreDefinitionError {}
#[derive(Debug, PartialEq)]
pub enum GetCoreDefinitionVersionError {
BadRequest(String),
}
impl GetCoreDefinitionVersionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetCoreDefinitionVersionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetCoreDefinitionVersionError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetCoreDefinitionVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetCoreDefinitionVersionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetCoreDefinitionVersionError {}
#[derive(Debug, PartialEq)]
pub enum GetDeploymentStatusError {
BadRequest(String),
}
impl GetDeploymentStatusError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDeploymentStatusError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetDeploymentStatusError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDeploymentStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDeploymentStatusError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDeploymentStatusError {}
#[derive(Debug, PartialEq)]
pub enum GetDeviceDefinitionError {
BadRequest(String),
}
impl GetDeviceDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDeviceDefinitionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetDeviceDefinitionError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDeviceDefinitionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDeviceDefinitionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDeviceDefinitionError {}
#[derive(Debug, PartialEq)]
pub enum GetDeviceDefinitionVersionError {
BadRequest(String),
}
impl GetDeviceDefinitionVersionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetDeviceDefinitionVersionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetDeviceDefinitionVersionError::BadRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDeviceDefinitionVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDeviceDefinitionVersionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDeviceDefinitionVersionError {}
#[derive(Debug, PartialEq)]
pub enum GetFunctionDefinitionError {
BadRequest(String),
}
impl GetFunctionDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetFunctionDefinitionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetFunctionDefinitionError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetFunctionDefinitionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetFunctionDefinitionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetFunctionDefinitionError {}
#[derive(Debug, PartialEq)]
pub enum GetFunctionDefinitionVersionError {
BadRequest(String),
}
impl GetFunctionDefinitionVersionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetFunctionDefinitionVersionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetFunctionDefinitionVersionError::BadRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetFunctionDefinitionVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetFunctionDefinitionVersionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetFunctionDefinitionVersionError {}
#[derive(Debug, PartialEq)]
pub enum GetGroupError {
BadRequest(String),
}
impl GetGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetGroupError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetGroupError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetGroupError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetGroupError {}
#[derive(Debug, PartialEq)]
pub enum GetGroupCertificateAuthorityError {
BadRequest(String),
InternalServerError(String),
}
impl GetGroupCertificateAuthorityError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetGroupCertificateAuthorityError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetGroupCertificateAuthorityError::BadRequest(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
GetGroupCertificateAuthorityError::InternalServerError(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetGroupCertificateAuthorityError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetGroupCertificateAuthorityError::BadRequest(ref cause) => write!(f, "{}", cause),
GetGroupCertificateAuthorityError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetGroupCertificateAuthorityError {}
#[derive(Debug, PartialEq)]
pub enum GetGroupCertificateConfigurationError {
BadRequest(String),
InternalServerError(String),
}
impl GetGroupCertificateConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetGroupCertificateConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetGroupCertificateConfigurationError::BadRequest(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
GetGroupCertificateConfigurationError::InternalServerError(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetGroupCertificateConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetGroupCertificateConfigurationError::BadRequest(ref cause) => write!(f, "{}", cause),
GetGroupCertificateConfigurationError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetGroupCertificateConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum GetGroupVersionError {
BadRequest(String),
}
impl GetGroupVersionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetGroupVersionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetGroupVersionError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetGroupVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetGroupVersionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetGroupVersionError {}
#[derive(Debug, PartialEq)]
pub enum GetLoggerDefinitionError {
BadRequest(String),
}
impl GetLoggerDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetLoggerDefinitionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetLoggerDefinitionError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetLoggerDefinitionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetLoggerDefinitionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetLoggerDefinitionError {}
#[derive(Debug, PartialEq)]
pub enum GetLoggerDefinitionVersionError {
BadRequest(String),
}
impl GetLoggerDefinitionVersionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetLoggerDefinitionVersionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetLoggerDefinitionVersionError::BadRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetLoggerDefinitionVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetLoggerDefinitionVersionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetLoggerDefinitionVersionError {}
#[derive(Debug, PartialEq)]
pub enum GetResourceDefinitionError {
BadRequest(String),
}
impl GetResourceDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetResourceDefinitionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetResourceDefinitionError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetResourceDefinitionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetResourceDefinitionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetResourceDefinitionError {}
#[derive(Debug, PartialEq)]
pub enum GetResourceDefinitionVersionError {
BadRequest(String),
}
impl GetResourceDefinitionVersionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetResourceDefinitionVersionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetResourceDefinitionVersionError::BadRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetResourceDefinitionVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetResourceDefinitionVersionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetResourceDefinitionVersionError {}
#[derive(Debug, PartialEq)]
pub enum GetServiceRoleForAccountError {
InternalServerError(String),
}
impl GetServiceRoleForAccountError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetServiceRoleForAccountError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalServerErrorException" => {
return RusotoError::Service(
GetServiceRoleForAccountError::InternalServerError(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetServiceRoleForAccountError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetServiceRoleForAccountError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetServiceRoleForAccountError {}
#[derive(Debug, PartialEq)]
pub enum GetSubscriptionDefinitionError {
BadRequest(String),
}
impl GetSubscriptionDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetSubscriptionDefinitionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetSubscriptionDefinitionError::BadRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetSubscriptionDefinitionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetSubscriptionDefinitionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetSubscriptionDefinitionError {}
#[derive(Debug, PartialEq)]
pub enum GetSubscriptionDefinitionVersionError {
BadRequest(String),
}
impl GetSubscriptionDefinitionVersionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetSubscriptionDefinitionVersionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetSubscriptionDefinitionVersionError::BadRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetSubscriptionDefinitionVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetSubscriptionDefinitionVersionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetSubscriptionDefinitionVersionError {}
#[derive(Debug, PartialEq)]
pub enum GetThingRuntimeConfigurationError {
BadRequest(String),
InternalServerError(String),
}
impl GetThingRuntimeConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetThingRuntimeConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetThingRuntimeConfigurationError::BadRequest(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
GetThingRuntimeConfigurationError::InternalServerError(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetThingRuntimeConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetThingRuntimeConfigurationError::BadRequest(ref cause) => write!(f, "{}", cause),
GetThingRuntimeConfigurationError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetThingRuntimeConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum ListBulkDeploymentDetailedReportsError {
BadRequest(String),
}
impl ListBulkDeploymentDetailedReportsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListBulkDeploymentDetailedReportsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(
ListBulkDeploymentDetailedReportsError::BadRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListBulkDeploymentDetailedReportsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListBulkDeploymentDetailedReportsError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListBulkDeploymentDetailedReportsError {}
#[derive(Debug, PartialEq)]
pub enum ListBulkDeploymentsError {
BadRequest(String),
}
impl ListBulkDeploymentsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListBulkDeploymentsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListBulkDeploymentsError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListBulkDeploymentsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListBulkDeploymentsError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListBulkDeploymentsError {}
#[derive(Debug, PartialEq)]
pub enum ListConnectorDefinitionVersionsError {
BadRequest(String),
}
impl ListConnectorDefinitionVersionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListConnectorDefinitionVersionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListConnectorDefinitionVersionsError::BadRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListConnectorDefinitionVersionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListConnectorDefinitionVersionsError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListConnectorDefinitionVersionsError {}
#[derive(Debug, PartialEq)]
pub enum ListConnectorDefinitionsError {}
impl ListConnectorDefinitionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListConnectorDefinitionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListConnectorDefinitionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for ListConnectorDefinitionsError {}
#[derive(Debug, PartialEq)]
pub enum ListCoreDefinitionVersionsError {
BadRequest(String),
}
impl ListCoreDefinitionVersionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListCoreDefinitionVersionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListCoreDefinitionVersionsError::BadRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListCoreDefinitionVersionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListCoreDefinitionVersionsError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListCoreDefinitionVersionsError {}
#[derive(Debug, PartialEq)]
pub enum ListCoreDefinitionsError {}
impl ListCoreDefinitionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListCoreDefinitionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListCoreDefinitionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for ListCoreDefinitionsError {}
#[derive(Debug, PartialEq)]
pub enum ListDeploymentsError {
BadRequest(String),
}
impl ListDeploymentsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDeploymentsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListDeploymentsError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDeploymentsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDeploymentsError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDeploymentsError {}
#[derive(Debug, PartialEq)]
pub enum ListDeviceDefinitionVersionsError {
BadRequest(String),
}
impl ListDeviceDefinitionVersionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListDeviceDefinitionVersionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListDeviceDefinitionVersionsError::BadRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDeviceDefinitionVersionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDeviceDefinitionVersionsError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDeviceDefinitionVersionsError {}
#[derive(Debug, PartialEq)]
pub enum ListDeviceDefinitionsError {}
impl ListDeviceDefinitionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDeviceDefinitionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDeviceDefinitionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for ListDeviceDefinitionsError {}
#[derive(Debug, PartialEq)]
pub enum ListFunctionDefinitionVersionsError {
BadRequest(String),
}
impl ListFunctionDefinitionVersionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListFunctionDefinitionVersionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListFunctionDefinitionVersionsError::BadRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListFunctionDefinitionVersionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListFunctionDefinitionVersionsError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListFunctionDefinitionVersionsError {}
#[derive(Debug, PartialEq)]
pub enum ListFunctionDefinitionsError {}
impl ListFunctionDefinitionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListFunctionDefinitionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListFunctionDefinitionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for ListFunctionDefinitionsError {}
#[derive(Debug, PartialEq)]
pub enum ListGroupCertificateAuthoritiesError {
BadRequest(String),
InternalServerError(String),
}
impl ListGroupCertificateAuthoritiesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListGroupCertificateAuthoritiesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListGroupCertificateAuthoritiesError::BadRequest(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
ListGroupCertificateAuthoritiesError::InternalServerError(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListGroupCertificateAuthoritiesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListGroupCertificateAuthoritiesError::BadRequest(ref cause) => write!(f, "{}", cause),
ListGroupCertificateAuthoritiesError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListGroupCertificateAuthoritiesError {}
#[derive(Debug, PartialEq)]
pub enum ListGroupVersionsError {
BadRequest(String),
}
impl ListGroupVersionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListGroupVersionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListGroupVersionsError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListGroupVersionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListGroupVersionsError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListGroupVersionsError {}
#[derive(Debug, PartialEq)]
pub enum ListGroupsError {}
impl ListGroupsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListGroupsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListGroupsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for ListGroupsError {}
#[derive(Debug, PartialEq)]
pub enum ListLoggerDefinitionVersionsError {
BadRequest(String),
}
impl ListLoggerDefinitionVersionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListLoggerDefinitionVersionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListLoggerDefinitionVersionsError::BadRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListLoggerDefinitionVersionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListLoggerDefinitionVersionsError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListLoggerDefinitionVersionsError {}
#[derive(Debug, PartialEq)]
pub enum ListLoggerDefinitionsError {}
impl ListLoggerDefinitionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListLoggerDefinitionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListLoggerDefinitionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for ListLoggerDefinitionsError {}
#[derive(Debug, PartialEq)]
pub enum ListResourceDefinitionVersionsError {
BadRequest(String),
}
impl ListResourceDefinitionVersionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListResourceDefinitionVersionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListResourceDefinitionVersionsError::BadRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListResourceDefinitionVersionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListResourceDefinitionVersionsError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListResourceDefinitionVersionsError {}
#[derive(Debug, PartialEq)]
pub enum ListResourceDefinitionsError {}
impl ListResourceDefinitionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListResourceDefinitionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListResourceDefinitionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for ListResourceDefinitionsError {}
#[derive(Debug, PartialEq)]
pub enum ListSubscriptionDefinitionVersionsError {
BadRequest(String),
}
impl ListSubscriptionDefinitionVersionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListSubscriptionDefinitionVersionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(
ListSubscriptionDefinitionVersionsError::BadRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListSubscriptionDefinitionVersionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListSubscriptionDefinitionVersionsError::BadRequest(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListSubscriptionDefinitionVersionsError {}
#[derive(Debug, PartialEq)]
pub enum ListSubscriptionDefinitionsError {}
impl ListSubscriptionDefinitionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListSubscriptionDefinitionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListSubscriptionDefinitionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for ListSubscriptionDefinitionsError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
BadRequest(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListTagsForResourceError::BadRequest(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::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum ResetDeploymentsError {
BadRequest(String),
}
impl ResetDeploymentsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ResetDeploymentsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ResetDeploymentsError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ResetDeploymentsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ResetDeploymentsError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ResetDeploymentsError {}
#[derive(Debug, PartialEq)]
pub enum StartBulkDeploymentError {
BadRequest(String),
}
impl StartBulkDeploymentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartBulkDeploymentError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(StartBulkDeploymentError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartBulkDeploymentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartBulkDeploymentError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartBulkDeploymentError {}
#[derive(Debug, PartialEq)]
pub enum StopBulkDeploymentError {
BadRequest(String),
}
impl StopBulkDeploymentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopBulkDeploymentError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(StopBulkDeploymentError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StopBulkDeploymentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StopBulkDeploymentError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StopBulkDeploymentError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
BadRequest(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(TagResourceError::BadRequest(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::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
BadRequest(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UntagResourceError::BadRequest(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::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateConnectivityInfoError {
BadRequest(String),
InternalServerError(String),
}
impl UpdateConnectivityInfoError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateConnectivityInfoError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateConnectivityInfoError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(UpdateConnectivityInfoError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateConnectivityInfoError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateConnectivityInfoError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateConnectivityInfoError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateConnectivityInfoError {}
#[derive(Debug, PartialEq)]
pub enum UpdateConnectorDefinitionError {
BadRequest(String),
}
impl UpdateConnectorDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateConnectorDefinitionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateConnectorDefinitionError::BadRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateConnectorDefinitionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateConnectorDefinitionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateConnectorDefinitionError {}
#[derive(Debug, PartialEq)]
pub enum UpdateCoreDefinitionError {
BadRequest(String),
}
impl UpdateCoreDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateCoreDefinitionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateCoreDefinitionError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateCoreDefinitionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateCoreDefinitionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateCoreDefinitionError {}
#[derive(Debug, PartialEq)]
pub enum UpdateDeviceDefinitionError {
BadRequest(String),
}
impl UpdateDeviceDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateDeviceDefinitionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateDeviceDefinitionError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateDeviceDefinitionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateDeviceDefinitionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateDeviceDefinitionError {}
#[derive(Debug, PartialEq)]
pub enum UpdateFunctionDefinitionError {
BadRequest(String),
}
impl UpdateFunctionDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateFunctionDefinitionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateFunctionDefinitionError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateFunctionDefinitionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateFunctionDefinitionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateFunctionDefinitionError {}
#[derive(Debug, PartialEq)]
pub enum UpdateGroupError {
BadRequest(String),
}
impl UpdateGroupError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateGroupError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateGroupError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateGroupError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateGroupError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateGroupError {}
#[derive(Debug, PartialEq)]
pub enum UpdateGroupCertificateConfigurationError {
BadRequest(String),
InternalServerError(String),
}
impl UpdateGroupCertificateConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateGroupCertificateConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(
UpdateGroupCertificateConfigurationError::BadRequest(err.msg),
)
}
"InternalServerErrorException" => {
return RusotoError::Service(
UpdateGroupCertificateConfigurationError::InternalServerError(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateGroupCertificateConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateGroupCertificateConfigurationError::BadRequest(ref cause) => {
write!(f, "{}", cause)
}
UpdateGroupCertificateConfigurationError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateGroupCertificateConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum UpdateLoggerDefinitionError {
BadRequest(String),
}
impl UpdateLoggerDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateLoggerDefinitionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateLoggerDefinitionError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateLoggerDefinitionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateLoggerDefinitionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateLoggerDefinitionError {}
#[derive(Debug, PartialEq)]
pub enum UpdateResourceDefinitionError {
BadRequest(String),
}
impl UpdateResourceDefinitionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateResourceDefinitionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateResourceDefinitionError::BadRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateResourceDefinitionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateResourceDefinitionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateResourceDefinitionError {}
#[derive(Debug, PartialEq)]
pub enum UpdateSubscriptionDefinitionError {
BadRequest(String),
}
impl UpdateSubscriptionDefinitionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateSubscriptionDefinitionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateSubscriptionDefinitionError::BadRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateSubscriptionDefinitionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateSubscriptionDefinitionError::BadRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateSubscriptionDefinitionError {}
#[derive(Debug, PartialEq)]
pub enum UpdateThingRuntimeConfigurationError {
BadRequest(String),
InternalServerError(String),
}
impl UpdateThingRuntimeConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateThingRuntimeConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateThingRuntimeConfigurationError::BadRequest(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
UpdateThingRuntimeConfigurationError::InternalServerError(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateThingRuntimeConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateThingRuntimeConfigurationError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateThingRuntimeConfigurationError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateThingRuntimeConfigurationError {}
#[async_trait]
pub trait GreenGrass {
async fn associate_role_to_group(
&self,
input: AssociateRoleToGroupRequest,
) -> Result<AssociateRoleToGroupResponse, RusotoError<AssociateRoleToGroupError>>;
async fn associate_service_role_to_account(
&self,
input: AssociateServiceRoleToAccountRequest,
) -> Result<
AssociateServiceRoleToAccountResponse,
RusotoError<AssociateServiceRoleToAccountError>,
>;
async fn create_connector_definition(
&self,
input: CreateConnectorDefinitionRequest,
) -> Result<CreateConnectorDefinitionResponse, RusotoError<CreateConnectorDefinitionError>>;
async fn create_connector_definition_version(
&self,
input: CreateConnectorDefinitionVersionRequest,
) -> Result<
CreateConnectorDefinitionVersionResponse,
RusotoError<CreateConnectorDefinitionVersionError>,
>;
async fn create_core_definition(
&self,
input: CreateCoreDefinitionRequest,
) -> Result<CreateCoreDefinitionResponse, RusotoError<CreateCoreDefinitionError>>;
async fn create_core_definition_version(
&self,
input: CreateCoreDefinitionVersionRequest,
) -> Result<CreateCoreDefinitionVersionResponse, RusotoError<CreateCoreDefinitionVersionError>>;
async fn create_deployment(
&self,
input: CreateDeploymentRequest,
) -> Result<CreateDeploymentResponse, RusotoError<CreateDeploymentError>>;
async fn create_device_definition(
&self,
input: CreateDeviceDefinitionRequest,
) -> Result<CreateDeviceDefinitionResponse, RusotoError<CreateDeviceDefinitionError>>;
async fn create_device_definition_version(
&self,
input: CreateDeviceDefinitionVersionRequest,
) -> Result<
CreateDeviceDefinitionVersionResponse,
RusotoError<CreateDeviceDefinitionVersionError>,
>;
async fn create_function_definition(
&self,
input: CreateFunctionDefinitionRequest,
) -> Result<CreateFunctionDefinitionResponse, RusotoError<CreateFunctionDefinitionError>>;
async fn create_function_definition_version(
&self,
input: CreateFunctionDefinitionVersionRequest,
) -> Result<
CreateFunctionDefinitionVersionResponse,
RusotoError<CreateFunctionDefinitionVersionError>,
>;
async fn create_group(
&self,
input: CreateGroupRequest,
) -> Result<CreateGroupResponse, RusotoError<CreateGroupError>>;
async fn create_group_certificate_authority(
&self,
input: CreateGroupCertificateAuthorityRequest,
) -> Result<
CreateGroupCertificateAuthorityResponse,
RusotoError<CreateGroupCertificateAuthorityError>,
>;
async fn create_group_version(
&self,
input: CreateGroupVersionRequest,
) -> Result<CreateGroupVersionResponse, RusotoError<CreateGroupVersionError>>;
async fn create_logger_definition(
&self,
input: CreateLoggerDefinitionRequest,
) -> Result<CreateLoggerDefinitionResponse, RusotoError<CreateLoggerDefinitionError>>;
async fn create_logger_definition_version(
&self,
input: CreateLoggerDefinitionVersionRequest,
) -> Result<
CreateLoggerDefinitionVersionResponse,
RusotoError<CreateLoggerDefinitionVersionError>,
>;
async fn create_resource_definition(
&self,
input: CreateResourceDefinitionRequest,
) -> Result<CreateResourceDefinitionResponse, RusotoError<CreateResourceDefinitionError>>;
async fn create_resource_definition_version(
&self,
input: CreateResourceDefinitionVersionRequest,
) -> Result<
CreateResourceDefinitionVersionResponse,
RusotoError<CreateResourceDefinitionVersionError>,
>;
async fn create_software_update_job(
&self,
input: CreateSoftwareUpdateJobRequest,
) -> Result<CreateSoftwareUpdateJobResponse, RusotoError<CreateSoftwareUpdateJobError>>;
async fn create_subscription_definition(
&self,
input: CreateSubscriptionDefinitionRequest,
) -> Result<CreateSubscriptionDefinitionResponse, RusotoError<CreateSubscriptionDefinitionError>>;
async fn create_subscription_definition_version(
&self,
input: CreateSubscriptionDefinitionVersionRequest,
) -> Result<
CreateSubscriptionDefinitionVersionResponse,
RusotoError<CreateSubscriptionDefinitionVersionError>,
>;
async fn delete_connector_definition(
&self,
input: DeleteConnectorDefinitionRequest,
) -> Result<DeleteConnectorDefinitionResponse, RusotoError<DeleteConnectorDefinitionError>>;
async fn delete_core_definition(
&self,
input: DeleteCoreDefinitionRequest,
) -> Result<DeleteCoreDefinitionResponse, RusotoError<DeleteCoreDefinitionError>>;
async fn delete_device_definition(
&self,
input: DeleteDeviceDefinitionRequest,
) -> Result<DeleteDeviceDefinitionResponse, RusotoError<DeleteDeviceDefinitionError>>;
async fn delete_function_definition(
&self,
input: DeleteFunctionDefinitionRequest,
) -> Result<DeleteFunctionDefinitionResponse, RusotoError<DeleteFunctionDefinitionError>>;
async fn delete_group(
&self,
input: DeleteGroupRequest,
) -> Result<DeleteGroupResponse, RusotoError<DeleteGroupError>>;
async fn delete_logger_definition(
&self,
input: DeleteLoggerDefinitionRequest,
) -> Result<DeleteLoggerDefinitionResponse, RusotoError<DeleteLoggerDefinitionError>>;
async fn delete_resource_definition(
&self,
input: DeleteResourceDefinitionRequest,
) -> Result<DeleteResourceDefinitionResponse, RusotoError<DeleteResourceDefinitionError>>;
async fn delete_subscription_definition(
&self,
input: DeleteSubscriptionDefinitionRequest,
) -> Result<DeleteSubscriptionDefinitionResponse, RusotoError<DeleteSubscriptionDefinitionError>>;
async fn disassociate_role_from_group(
&self,
input: DisassociateRoleFromGroupRequest,
) -> Result<DisassociateRoleFromGroupResponse, RusotoError<DisassociateRoleFromGroupError>>;
async fn disassociate_service_role_from_account(
&self,
) -> Result<
DisassociateServiceRoleFromAccountResponse,
RusotoError<DisassociateServiceRoleFromAccountError>,
>;
async fn get_associated_role(
&self,
input: GetAssociatedRoleRequest,
) -> Result<GetAssociatedRoleResponse, RusotoError<GetAssociatedRoleError>>;
async fn get_bulk_deployment_status(
&self,
input: GetBulkDeploymentStatusRequest,
) -> Result<GetBulkDeploymentStatusResponse, RusotoError<GetBulkDeploymentStatusError>>;
async fn get_connectivity_info(
&self,
input: GetConnectivityInfoRequest,
) -> Result<GetConnectivityInfoResponse, RusotoError<GetConnectivityInfoError>>;
async fn get_connector_definition(
&self,
input: GetConnectorDefinitionRequest,
) -> Result<GetConnectorDefinitionResponse, RusotoError<GetConnectorDefinitionError>>;
async fn get_connector_definition_version(
&self,
input: GetConnectorDefinitionVersionRequest,
) -> Result<
GetConnectorDefinitionVersionResponse,
RusotoError<GetConnectorDefinitionVersionError>,
>;
async fn get_core_definition(
&self,
input: GetCoreDefinitionRequest,
) -> Result<GetCoreDefinitionResponse, RusotoError<GetCoreDefinitionError>>;
async fn get_core_definition_version(
&self,
input: GetCoreDefinitionVersionRequest,
) -> Result<GetCoreDefinitionVersionResponse, RusotoError<GetCoreDefinitionVersionError>>;
async fn get_deployment_status(
&self,
input: GetDeploymentStatusRequest,
) -> Result<GetDeploymentStatusResponse, RusotoError<GetDeploymentStatusError>>;
async fn get_device_definition(
&self,
input: GetDeviceDefinitionRequest,
) -> Result<GetDeviceDefinitionResponse, RusotoError<GetDeviceDefinitionError>>;
async fn get_device_definition_version(
&self,
input: GetDeviceDefinitionVersionRequest,
) -> Result<GetDeviceDefinitionVersionResponse, RusotoError<GetDeviceDefinitionVersionError>>;
async fn get_function_definition(
&self,
input: GetFunctionDefinitionRequest,
) -> Result<GetFunctionDefinitionResponse, RusotoError<GetFunctionDefinitionError>>;
async fn get_function_definition_version(
&self,
input: GetFunctionDefinitionVersionRequest,
) -> Result<GetFunctionDefinitionVersionResponse, RusotoError<GetFunctionDefinitionVersionError>>;
async fn get_group(
&self,
input: GetGroupRequest,
) -> Result<GetGroupResponse, RusotoError<GetGroupError>>;
async fn get_group_certificate_authority(
&self,
input: GetGroupCertificateAuthorityRequest,
) -> Result<GetGroupCertificateAuthorityResponse, RusotoError<GetGroupCertificateAuthorityError>>;
async fn get_group_certificate_configuration(
&self,
input: GetGroupCertificateConfigurationRequest,
) -> Result<
GetGroupCertificateConfigurationResponse,
RusotoError<GetGroupCertificateConfigurationError>,
>;
async fn get_group_version(
&self,
input: GetGroupVersionRequest,
) -> Result<GetGroupVersionResponse, RusotoError<GetGroupVersionError>>;
async fn get_logger_definition(
&self,
input: GetLoggerDefinitionRequest,
) -> Result<GetLoggerDefinitionResponse, RusotoError<GetLoggerDefinitionError>>;
async fn get_logger_definition_version(
&self,
input: GetLoggerDefinitionVersionRequest,
) -> Result<GetLoggerDefinitionVersionResponse, RusotoError<GetLoggerDefinitionVersionError>>;
async fn get_resource_definition(
&self,
input: GetResourceDefinitionRequest,
) -> Result<GetResourceDefinitionResponse, RusotoError<GetResourceDefinitionError>>;
async fn get_resource_definition_version(
&self,
input: GetResourceDefinitionVersionRequest,
) -> Result<GetResourceDefinitionVersionResponse, RusotoError<GetResourceDefinitionVersionError>>;
async fn get_service_role_for_account(
&self,
) -> Result<GetServiceRoleForAccountResponse, RusotoError<GetServiceRoleForAccountError>>;
async fn get_subscription_definition(
&self,
input: GetSubscriptionDefinitionRequest,
) -> Result<GetSubscriptionDefinitionResponse, RusotoError<GetSubscriptionDefinitionError>>;
async fn get_subscription_definition_version(
&self,
input: GetSubscriptionDefinitionVersionRequest,
) -> Result<
GetSubscriptionDefinitionVersionResponse,
RusotoError<GetSubscriptionDefinitionVersionError>,
>;
async fn get_thing_runtime_configuration(
&self,
input: GetThingRuntimeConfigurationRequest,
) -> Result<GetThingRuntimeConfigurationResponse, RusotoError<GetThingRuntimeConfigurationError>>;
async fn list_bulk_deployment_detailed_reports(
&self,
input: ListBulkDeploymentDetailedReportsRequest,
) -> Result<
ListBulkDeploymentDetailedReportsResponse,
RusotoError<ListBulkDeploymentDetailedReportsError>,
>;
async fn list_bulk_deployments(
&self,
input: ListBulkDeploymentsRequest,
) -> Result<ListBulkDeploymentsResponse, RusotoError<ListBulkDeploymentsError>>;
async fn list_connector_definition_versions(
&self,
input: ListConnectorDefinitionVersionsRequest,
) -> Result<
ListConnectorDefinitionVersionsResponse,
RusotoError<ListConnectorDefinitionVersionsError>,
>;
async fn list_connector_definitions(
&self,
input: ListConnectorDefinitionsRequest,
) -> Result<ListConnectorDefinitionsResponse, RusotoError<ListConnectorDefinitionsError>>;
async fn list_core_definition_versions(
&self,
input: ListCoreDefinitionVersionsRequest,
) -> Result<ListCoreDefinitionVersionsResponse, RusotoError<ListCoreDefinitionVersionsError>>;
async fn list_core_definitions(
&self,
input: ListCoreDefinitionsRequest,
) -> Result<ListCoreDefinitionsResponse, RusotoError<ListCoreDefinitionsError>>;
async fn list_deployments(
&self,
input: ListDeploymentsRequest,
) -> Result<ListDeploymentsResponse, RusotoError<ListDeploymentsError>>;
async fn list_device_definition_versions(
&self,
input: ListDeviceDefinitionVersionsRequest,
) -> Result<ListDeviceDefinitionVersionsResponse, RusotoError<ListDeviceDefinitionVersionsError>>;
async fn list_device_definitions(
&self,
input: ListDeviceDefinitionsRequest,
) -> Result<ListDeviceDefinitionsResponse, RusotoError<ListDeviceDefinitionsError>>;
async fn list_function_definition_versions(
&self,
input: ListFunctionDefinitionVersionsRequest,
) -> Result<
ListFunctionDefinitionVersionsResponse,
RusotoError<ListFunctionDefinitionVersionsError>,
>;
async fn list_function_definitions(
&self,
input: ListFunctionDefinitionsRequest,
) -> Result<ListFunctionDefinitionsResponse, RusotoError<ListFunctionDefinitionsError>>;
async fn list_group_certificate_authorities(
&self,
input: ListGroupCertificateAuthoritiesRequest,
) -> Result<
ListGroupCertificateAuthoritiesResponse,
RusotoError<ListGroupCertificateAuthoritiesError>,
>;
async fn list_group_versions(
&self,
input: ListGroupVersionsRequest,
) -> Result<ListGroupVersionsResponse, RusotoError<ListGroupVersionsError>>;
async fn list_groups(
&self,
input: ListGroupsRequest,
) -> Result<ListGroupsResponse, RusotoError<ListGroupsError>>;
async fn list_logger_definition_versions(
&self,
input: ListLoggerDefinitionVersionsRequest,
) -> Result<ListLoggerDefinitionVersionsResponse, RusotoError<ListLoggerDefinitionVersionsError>>;
async fn list_logger_definitions(
&self,
input: ListLoggerDefinitionsRequest,
) -> Result<ListLoggerDefinitionsResponse, RusotoError<ListLoggerDefinitionsError>>;
async fn list_resource_definition_versions(
&self,
input: ListResourceDefinitionVersionsRequest,
) -> Result<
ListResourceDefinitionVersionsResponse,
RusotoError<ListResourceDefinitionVersionsError>,
>;
async fn list_resource_definitions(
&self,
input: ListResourceDefinitionsRequest,
) -> Result<ListResourceDefinitionsResponse, RusotoError<ListResourceDefinitionsError>>;
async fn list_subscription_definition_versions(
&self,
input: ListSubscriptionDefinitionVersionsRequest,
) -> Result<
ListSubscriptionDefinitionVersionsResponse,
RusotoError<ListSubscriptionDefinitionVersionsError>,
>;
async fn list_subscription_definitions(
&self,
input: ListSubscriptionDefinitionsRequest,
) -> Result<ListSubscriptionDefinitionsResponse, RusotoError<ListSubscriptionDefinitionsError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
async fn reset_deployments(
&self,
input: ResetDeploymentsRequest,
) -> Result<ResetDeploymentsResponse, RusotoError<ResetDeploymentsError>>;
async fn start_bulk_deployment(
&self,
input: StartBulkDeploymentRequest,
) -> Result<StartBulkDeploymentResponse, RusotoError<StartBulkDeploymentError>>;
async fn stop_bulk_deployment(
&self,
input: StopBulkDeploymentRequest,
) -> Result<StopBulkDeploymentResponse, RusotoError<StopBulkDeploymentError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<(), RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<(), RusotoError<UntagResourceError>>;
async fn update_connectivity_info(
&self,
input: UpdateConnectivityInfoRequest,
) -> Result<UpdateConnectivityInfoResponse, RusotoError<UpdateConnectivityInfoError>>;
async fn update_connector_definition(
&self,
input: UpdateConnectorDefinitionRequest,
) -> Result<UpdateConnectorDefinitionResponse, RusotoError<UpdateConnectorDefinitionError>>;
async fn update_core_definition(
&self,
input: UpdateCoreDefinitionRequest,
) -> Result<UpdateCoreDefinitionResponse, RusotoError<UpdateCoreDefinitionError>>;
async fn update_device_definition(
&self,
input: UpdateDeviceDefinitionRequest,
) -> Result<UpdateDeviceDefinitionResponse, RusotoError<UpdateDeviceDefinitionError>>;
async fn update_function_definition(
&self,
input: UpdateFunctionDefinitionRequest,
) -> Result<UpdateFunctionDefinitionResponse, RusotoError<UpdateFunctionDefinitionError>>;
async fn update_group(
&self,
input: UpdateGroupRequest,
) -> Result<UpdateGroupResponse, RusotoError<UpdateGroupError>>;
async fn update_group_certificate_configuration(
&self,
input: UpdateGroupCertificateConfigurationRequest,
) -> Result<
UpdateGroupCertificateConfigurationResponse,
RusotoError<UpdateGroupCertificateConfigurationError>,
>;
async fn update_logger_definition(
&self,
input: UpdateLoggerDefinitionRequest,
) -> Result<UpdateLoggerDefinitionResponse, RusotoError<UpdateLoggerDefinitionError>>;
async fn update_resource_definition(
&self,
input: UpdateResourceDefinitionRequest,
) -> Result<UpdateResourceDefinitionResponse, RusotoError<UpdateResourceDefinitionError>>;
async fn update_subscription_definition(
&self,
input: UpdateSubscriptionDefinitionRequest,
) -> Result<UpdateSubscriptionDefinitionResponse, RusotoError<UpdateSubscriptionDefinitionError>>;
async fn update_thing_runtime_configuration(
&self,
input: UpdateThingRuntimeConfigurationRequest,
) -> Result<
UpdateThingRuntimeConfigurationResponse,
RusotoError<UpdateThingRuntimeConfigurationError>,
>;
}
#[derive(Clone)]
pub struct GreenGrassClient {
client: Client,
region: region::Region,
}
impl GreenGrassClient {
pub fn new(region: region::Region) -> GreenGrassClient {
GreenGrassClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> GreenGrassClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
GreenGrassClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> GreenGrassClient {
GreenGrassClient { client, region }
}
}
#[async_trait]
impl GreenGrass for GreenGrassClient {
#[allow(unused_mut)]
async fn associate_role_to_group(
&self,
input: AssociateRoleToGroupRequest,
) -> Result<AssociateRoleToGroupResponse, RusotoError<AssociateRoleToGroupError>> {
let request_uri = format!(
"/greengrass/groups/{group_id}/role",
group_id = input.group_id
);
let mut request = SignedRequest::new("PUT", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<AssociateRoleToGroupResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(AssociateRoleToGroupError::from_response(response))
}
}
#[allow(unused_mut)]
async fn associate_service_role_to_account(
&self,
input: AssociateServiceRoleToAccountRequest,
) -> Result<
AssociateServiceRoleToAccountResponse,
RusotoError<AssociateServiceRoleToAccountError>,
> {
let request_uri = "/greengrass/servicerole";
let mut request = SignedRequest::new("PUT", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<AssociateServiceRoleToAccountResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(AssociateServiceRoleToAccountError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_connector_definition(
&self,
input: CreateConnectorDefinitionRequest,
) -> Result<CreateConnectorDefinitionResponse, RusotoError<CreateConnectorDefinitionError>>
{
let request_uri = "/greengrass/definition/connectors";
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("X-Amzn-Client-Token", input.amzn_client_token.as_ref());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateConnectorDefinitionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateConnectorDefinitionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_connector_definition_version(
&self,
input: CreateConnectorDefinitionVersionRequest,
) -> Result<
CreateConnectorDefinitionVersionResponse,
RusotoError<CreateConnectorDefinitionVersionError>,
> {
let request_uri = format!(
"/greengrass/definition/connectors/{connector_definition_id}/versions",
connector_definition_id = input.connector_definition_id
);
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("X-Amzn-Client-Token", input.amzn_client_token.as_ref());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateConnectorDefinitionVersionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateConnectorDefinitionVersionError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn create_core_definition(
&self,
input: CreateCoreDefinitionRequest,
) -> Result<CreateCoreDefinitionResponse, RusotoError<CreateCoreDefinitionError>> {
let request_uri = "/greengrass/definition/cores";
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("X-Amzn-Client-Token", input.amzn_client_token.as_ref());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateCoreDefinitionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateCoreDefinitionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_core_definition_version(
&self,
input: CreateCoreDefinitionVersionRequest,
) -> Result<CreateCoreDefinitionVersionResponse, RusotoError<CreateCoreDefinitionVersionError>>
{
let request_uri = format!(
"/greengrass/definition/cores/{core_definition_id}/versions",
core_definition_id = input.core_definition_id
);
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("X-Amzn-Client-Token", input.amzn_client_token.as_ref());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateCoreDefinitionVersionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateCoreDefinitionVersionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_deployment(
&self,
input: CreateDeploymentRequest,
) -> Result<CreateDeploymentResponse, RusotoError<CreateDeploymentError>> {
let request_uri = format!(
"/greengrass/groups/{group_id}/deployments",
group_id = input.group_id
);
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("X-Amzn-Client-Token", input.amzn_client_token.as_ref());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateDeploymentResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateDeploymentError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_device_definition(
&self,
input: CreateDeviceDefinitionRequest,
) -> Result<CreateDeviceDefinitionResponse, RusotoError<CreateDeviceDefinitionError>> {
let request_uri = "/greengrass/definition/devices";
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("X-Amzn-Client-Token", input.amzn_client_token.as_ref());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateDeviceDefinitionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateDeviceDefinitionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_device_definition_version(
&self,
input: CreateDeviceDefinitionVersionRequest,
) -> Result<
CreateDeviceDefinitionVersionResponse,
RusotoError<CreateDeviceDefinitionVersionError>,
> {
let request_uri = format!(
"/greengrass/definition/devices/{device_definition_id}/versions",
device_definition_id = input.device_definition_id
);
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("X-Amzn-Client-Token", input.amzn_client_token.as_ref());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateDeviceDefinitionVersionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateDeviceDefinitionVersionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_function_definition(
&self,
input: CreateFunctionDefinitionRequest,
) -> Result<CreateFunctionDefinitionResponse, RusotoError<CreateFunctionDefinitionError>> {
let request_uri = "/greengrass/definition/functions";
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("X-Amzn-Client-Token", input.amzn_client_token.as_ref());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateFunctionDefinitionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateFunctionDefinitionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_function_definition_version(
&self,
input: CreateFunctionDefinitionVersionRequest,
) -> Result<
CreateFunctionDefinitionVersionResponse,
RusotoError<CreateFunctionDefinitionVersionError>,
> {
let request_uri = format!(
"/greengrass/definition/functions/{function_definition_id}/versions",
function_definition_id = input.function_definition_id
);
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("X-Amzn-Client-Token", input.amzn_client_token.as_ref());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateFunctionDefinitionVersionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateFunctionDefinitionVersionError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn create_group(
&self,
input: CreateGroupRequest,
) -> Result<CreateGroupResponse, RusotoError<CreateGroupError>> {
let request_uri = "/greengrass/groups";
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("X-Amzn-Client-Token", input.amzn_client_token.as_ref());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateGroupResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateGroupError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_group_certificate_authority(
&self,
input: CreateGroupCertificateAuthorityRequest,
) -> Result<
CreateGroupCertificateAuthorityResponse,
RusotoError<CreateGroupCertificateAuthorityError>,
> {
let request_uri = format!(
"/greengrass/groups/{group_id}/certificateauthorities",
group_id = input.group_id
);
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_optional_header("X-Amzn-Client-Token", input.amzn_client_token.as_ref());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateGroupCertificateAuthorityResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateGroupCertificateAuthorityError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn create_group_version(
&self,
input: CreateGroupVersionRequest,
) -> Result<CreateGroupVersionResponse, RusotoError<CreateGroupVersionError>> {
let request_uri = format!(
"/greengrass/groups/{group_id}/versions",
group_id = input.group_id
);
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("X-Amzn-Client-Token", input.amzn_client_token.as_ref());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateGroupVersionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateGroupVersionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_logger_definition(
&self,
input: CreateLoggerDefinitionRequest,
) -> Result<CreateLoggerDefinitionResponse, RusotoError<CreateLoggerDefinitionError>> {
let request_uri = "/greengrass/definition/loggers";
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("X-Amzn-Client-Token", input.amzn_client_token.as_ref());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateLoggerDefinitionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateLoggerDefinitionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_logger_definition_version(
&self,
input: CreateLoggerDefinitionVersionRequest,
) -> Result<
CreateLoggerDefinitionVersionResponse,
RusotoError<CreateLoggerDefinitionVersionError>,
> {
let request_uri = format!(
"/greengrass/definition/loggers/{logger_definition_id}/versions",
logger_definition_id = input.logger_definition_id
);
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("X-Amzn-Client-Token", input.amzn_client_token.as_ref());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateLoggerDefinitionVersionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateLoggerDefinitionVersionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_resource_definition(
&self,
input: CreateResourceDefinitionRequest,
) -> Result<CreateResourceDefinitionResponse, RusotoError<CreateResourceDefinitionError>> {
let request_uri = "/greengrass/definition/resources";
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("X-Amzn-Client-Token", input.amzn_client_token.as_ref());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateResourceDefinitionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateResourceDefinitionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_resource_definition_version(
&self,
input: CreateResourceDefinitionVersionRequest,
) -> Result<
CreateResourceDefinitionVersionResponse,
RusotoError<CreateResourceDefinitionVersionError>,
> {
let request_uri = format!(
"/greengrass/definition/resources/{resource_definition_id}/versions",
resource_definition_id = input.resource_definition_id
);
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("X-Amzn-Client-Token", input.amzn_client_token.as_ref());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateResourceDefinitionVersionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateResourceDefinitionVersionError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn create_software_update_job(
&self,
input: CreateSoftwareUpdateJobRequest,
) -> Result<CreateSoftwareUpdateJobResponse, RusotoError<CreateSoftwareUpdateJobError>> {
let request_uri = "/greengrass/updates";
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("X-Amzn-Client-Token", input.amzn_client_token.as_ref());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateSoftwareUpdateJobResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateSoftwareUpdateJobError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_subscription_definition(
&self,
input: CreateSubscriptionDefinitionRequest,
) -> Result<CreateSubscriptionDefinitionResponse, RusotoError<CreateSubscriptionDefinitionError>>
{
let request_uri = "/greengrass/definition/subscriptions";
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("X-Amzn-Client-Token", input.amzn_client_token.as_ref());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateSubscriptionDefinitionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateSubscriptionDefinitionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_subscription_definition_version(
&self,
input: CreateSubscriptionDefinitionVersionRequest,
) -> Result<
CreateSubscriptionDefinitionVersionResponse,
RusotoError<CreateSubscriptionDefinitionVersionError>,
> {
let request_uri = format!(
"/greengrass/definition/subscriptions/{subscription_definition_id}/versions",
subscription_definition_id = input.subscription_definition_id
);
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("X-Amzn-Client-Token", input.amzn_client_token.as_ref());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateSubscriptionDefinitionVersionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateSubscriptionDefinitionVersionError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn delete_connector_definition(
&self,
input: DeleteConnectorDefinitionRequest,
) -> Result<DeleteConnectorDefinitionResponse, RusotoError<DeleteConnectorDefinitionError>>
{
let request_uri = format!(
"/greengrass/definition/connectors/{connector_definition_id}",
connector_definition_id = input.connector_definition_id
);
let mut request = SignedRequest::new("DELETE", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteConnectorDefinitionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteConnectorDefinitionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_core_definition(
&self,
input: DeleteCoreDefinitionRequest,
) -> Result<DeleteCoreDefinitionResponse, RusotoError<DeleteCoreDefinitionError>> {
let request_uri = format!(
"/greengrass/definition/cores/{core_definition_id}",
core_definition_id = input.core_definition_id
);
let mut request = SignedRequest::new("DELETE", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteCoreDefinitionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteCoreDefinitionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_device_definition(
&self,
input: DeleteDeviceDefinitionRequest,
) -> Result<DeleteDeviceDefinitionResponse, RusotoError<DeleteDeviceDefinitionError>> {
let request_uri = format!(
"/greengrass/definition/devices/{device_definition_id}",
device_definition_id = input.device_definition_id
);
let mut request = SignedRequest::new("DELETE", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteDeviceDefinitionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteDeviceDefinitionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_function_definition(
&self,
input: DeleteFunctionDefinitionRequest,
) -> Result<DeleteFunctionDefinitionResponse, RusotoError<DeleteFunctionDefinitionError>> {
let request_uri = format!(
"/greengrass/definition/functions/{function_definition_id}",
function_definition_id = input.function_definition_id
);
let mut request = SignedRequest::new("DELETE", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteFunctionDefinitionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteFunctionDefinitionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_group(
&self,
input: DeleteGroupRequest,
) -> Result<DeleteGroupResponse, RusotoError<DeleteGroupError>> {
let request_uri = format!("/greengrass/groups/{group_id}", group_id = input.group_id);
let mut request = SignedRequest::new("DELETE", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteGroupResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteGroupError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_logger_definition(
&self,
input: DeleteLoggerDefinitionRequest,
) -> Result<DeleteLoggerDefinitionResponse, RusotoError<DeleteLoggerDefinitionError>> {
let request_uri = format!(
"/greengrass/definition/loggers/{logger_definition_id}",
logger_definition_id = input.logger_definition_id
);
let mut request = SignedRequest::new("DELETE", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteLoggerDefinitionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteLoggerDefinitionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_resource_definition(
&self,
input: DeleteResourceDefinitionRequest,
) -> Result<DeleteResourceDefinitionResponse, RusotoError<DeleteResourceDefinitionError>> {
let request_uri = format!(
"/greengrass/definition/resources/{resource_definition_id}",
resource_definition_id = input.resource_definition_id
);
let mut request = SignedRequest::new("DELETE", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteResourceDefinitionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteResourceDefinitionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_subscription_definition(
&self,
input: DeleteSubscriptionDefinitionRequest,
) -> Result<DeleteSubscriptionDefinitionResponse, RusotoError<DeleteSubscriptionDefinitionError>>
{
let request_uri = format!(
"/greengrass/definition/subscriptions/{subscription_definition_id}",
subscription_definition_id = input.subscription_definition_id
);
let mut request = SignedRequest::new("DELETE", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteSubscriptionDefinitionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteSubscriptionDefinitionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn disassociate_role_from_group(
&self,
input: DisassociateRoleFromGroupRequest,
) -> Result<DisassociateRoleFromGroupResponse, RusotoError<DisassociateRoleFromGroupError>>
{
let request_uri = format!(
"/greengrass/groups/{group_id}/role",
group_id = input.group_id
);
let mut request = SignedRequest::new("DELETE", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DisassociateRoleFromGroupResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DisassociateRoleFromGroupError::from_response(response))
}
}
#[allow(unused_mut)]
async fn disassociate_service_role_from_account(
&self,
) -> Result<
DisassociateServiceRoleFromAccountResponse,
RusotoError<DisassociateServiceRoleFromAccountError>,
> {
let request_uri = "/greengrass/servicerole";
let mut request = SignedRequest::new("DELETE", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DisassociateServiceRoleFromAccountResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DisassociateServiceRoleFromAccountError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn get_associated_role(
&self,
input: GetAssociatedRoleRequest,
) -> Result<GetAssociatedRoleResponse, RusotoError<GetAssociatedRoleError>> {
let request_uri = format!(
"/greengrass/groups/{group_id}/role",
group_id = input.group_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetAssociatedRoleResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetAssociatedRoleError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_bulk_deployment_status(
&self,
input: GetBulkDeploymentStatusRequest,
) -> Result<GetBulkDeploymentStatusResponse, RusotoError<GetBulkDeploymentStatusError>> {
let request_uri = format!(
"/greengrass/bulk/deployments/{bulk_deployment_id}/status",
bulk_deployment_id = input.bulk_deployment_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetBulkDeploymentStatusResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetBulkDeploymentStatusError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_connectivity_info(
&self,
input: GetConnectivityInfoRequest,
) -> Result<GetConnectivityInfoResponse, RusotoError<GetConnectivityInfoError>> {
let request_uri = format!(
"/greengrass/things/{thing_name}/connectivityInfo",
thing_name = input.thing_name
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetConnectivityInfoResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetConnectivityInfoError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_connector_definition(
&self,
input: GetConnectorDefinitionRequest,
) -> Result<GetConnectorDefinitionResponse, RusotoError<GetConnectorDefinitionError>> {
let request_uri = format!(
"/greengrass/definition/connectors/{connector_definition_id}",
connector_definition_id = input.connector_definition_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetConnectorDefinitionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetConnectorDefinitionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_connector_definition_version(
&self,
input: GetConnectorDefinitionVersionRequest,
) -> Result<
GetConnectorDefinitionVersionResponse,
RusotoError<GetConnectorDefinitionVersionError>,
> {
let request_uri = format!("/greengrass/definition/connectors/{connector_definition_id}/versions/{connector_definition_version_id}", connector_definition_id = input.connector_definition_id, connector_definition_version_id = input.connector_definition_version_id);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetConnectorDefinitionVersionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetConnectorDefinitionVersionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_core_definition(
&self,
input: GetCoreDefinitionRequest,
) -> Result<GetCoreDefinitionResponse, RusotoError<GetCoreDefinitionError>> {
let request_uri = format!(
"/greengrass/definition/cores/{core_definition_id}",
core_definition_id = input.core_definition_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetCoreDefinitionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetCoreDefinitionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_core_definition_version(
&self,
input: GetCoreDefinitionVersionRequest,
) -> Result<GetCoreDefinitionVersionResponse, RusotoError<GetCoreDefinitionVersionError>> {
let request_uri = format!("/greengrass/definition/cores/{core_definition_id}/versions/{core_definition_version_id}", core_definition_id = input.core_definition_id, core_definition_version_id = input.core_definition_version_id);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetCoreDefinitionVersionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetCoreDefinitionVersionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_deployment_status(
&self,
input: GetDeploymentStatusRequest,
) -> Result<GetDeploymentStatusResponse, RusotoError<GetDeploymentStatusError>> {
let request_uri = format!(
"/greengrass/groups/{group_id}/deployments/{deployment_id}/status",
deployment_id = input.deployment_id,
group_id = input.group_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetDeploymentStatusResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetDeploymentStatusError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_device_definition(
&self,
input: GetDeviceDefinitionRequest,
) -> Result<GetDeviceDefinitionResponse, RusotoError<GetDeviceDefinitionError>> {
let request_uri = format!(
"/greengrass/definition/devices/{device_definition_id}",
device_definition_id = input.device_definition_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetDeviceDefinitionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetDeviceDefinitionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_device_definition_version(
&self,
input: GetDeviceDefinitionVersionRequest,
) -> Result<GetDeviceDefinitionVersionResponse, RusotoError<GetDeviceDefinitionVersionError>>
{
let request_uri = format!("/greengrass/definition/devices/{device_definition_id}/versions/{device_definition_version_id}", device_definition_id = input.device_definition_id, device_definition_version_id = input.device_definition_version_id);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetDeviceDefinitionVersionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetDeviceDefinitionVersionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_function_definition(
&self,
input: GetFunctionDefinitionRequest,
) -> Result<GetFunctionDefinitionResponse, RusotoError<GetFunctionDefinitionError>> {
let request_uri = format!(
"/greengrass/definition/functions/{function_definition_id}",
function_definition_id = input.function_definition_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetFunctionDefinitionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetFunctionDefinitionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_function_definition_version(
&self,
input: GetFunctionDefinitionVersionRequest,
) -> Result<GetFunctionDefinitionVersionResponse, RusotoError<GetFunctionDefinitionVersionError>>
{
let request_uri = format!("/greengrass/definition/functions/{function_definition_id}/versions/{function_definition_version_id}", function_definition_id = input.function_definition_id, function_definition_version_id = input.function_definition_version_id);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetFunctionDefinitionVersionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetFunctionDefinitionVersionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_group(
&self,
input: GetGroupRequest,
) -> Result<GetGroupResponse, RusotoError<GetGroupError>> {
let request_uri = format!("/greengrass/groups/{group_id}", group_id = input.group_id);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetGroupResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetGroupError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_group_certificate_authority(
&self,
input: GetGroupCertificateAuthorityRequest,
) -> Result<GetGroupCertificateAuthorityResponse, RusotoError<GetGroupCertificateAuthorityError>>
{
let request_uri = format!(
"/greengrass/groups/{group_id}/certificateauthorities/{certificate_authority_id}",
certificate_authority_id = input.certificate_authority_id,
group_id = input.group_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetGroupCertificateAuthorityResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetGroupCertificateAuthorityError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_group_certificate_configuration(
&self,
input: GetGroupCertificateConfigurationRequest,
) -> Result<
GetGroupCertificateConfigurationResponse,
RusotoError<GetGroupCertificateConfigurationError>,
> {
let request_uri = format!(
"/greengrass/groups/{group_id}/certificateauthorities/configuration/expiry",
group_id = input.group_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetGroupCertificateConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetGroupCertificateConfigurationError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn get_group_version(
&self,
input: GetGroupVersionRequest,
) -> Result<GetGroupVersionResponse, RusotoError<GetGroupVersionError>> {
let request_uri = format!(
"/greengrass/groups/{group_id}/versions/{group_version_id}",
group_id = input.group_id,
group_version_id = input.group_version_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetGroupVersionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetGroupVersionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_logger_definition(
&self,
input: GetLoggerDefinitionRequest,
) -> Result<GetLoggerDefinitionResponse, RusotoError<GetLoggerDefinitionError>> {
let request_uri = format!(
"/greengrass/definition/loggers/{logger_definition_id}",
logger_definition_id = input.logger_definition_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetLoggerDefinitionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetLoggerDefinitionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_logger_definition_version(
&self,
input: GetLoggerDefinitionVersionRequest,
) -> Result<GetLoggerDefinitionVersionResponse, RusotoError<GetLoggerDefinitionVersionError>>
{
let request_uri = format!("/greengrass/definition/loggers/{logger_definition_id}/versions/{logger_definition_version_id}", logger_definition_id = input.logger_definition_id, logger_definition_version_id = input.logger_definition_version_id);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetLoggerDefinitionVersionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetLoggerDefinitionVersionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_resource_definition(
&self,
input: GetResourceDefinitionRequest,
) -> Result<GetResourceDefinitionResponse, RusotoError<GetResourceDefinitionError>> {
let request_uri = format!(
"/greengrass/definition/resources/{resource_definition_id}",
resource_definition_id = input.resource_definition_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetResourceDefinitionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetResourceDefinitionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_resource_definition_version(
&self,
input: GetResourceDefinitionVersionRequest,
) -> Result<GetResourceDefinitionVersionResponse, RusotoError<GetResourceDefinitionVersionError>>
{
let request_uri = format!("/greengrass/definition/resources/{resource_definition_id}/versions/{resource_definition_version_id}", resource_definition_id = input.resource_definition_id, resource_definition_version_id = input.resource_definition_version_id);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetResourceDefinitionVersionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetResourceDefinitionVersionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_service_role_for_account(
&self,
) -> Result<GetServiceRoleForAccountResponse, RusotoError<GetServiceRoleForAccountError>> {
let request_uri = "/greengrass/servicerole";
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetServiceRoleForAccountResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetServiceRoleForAccountError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_subscription_definition(
&self,
input: GetSubscriptionDefinitionRequest,
) -> Result<GetSubscriptionDefinitionResponse, RusotoError<GetSubscriptionDefinitionError>>
{
let request_uri = format!(
"/greengrass/definition/subscriptions/{subscription_definition_id}",
subscription_definition_id = input.subscription_definition_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetSubscriptionDefinitionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetSubscriptionDefinitionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_subscription_definition_version(
&self,
input: GetSubscriptionDefinitionVersionRequest,
) -> Result<
GetSubscriptionDefinitionVersionResponse,
RusotoError<GetSubscriptionDefinitionVersionError>,
> {
let request_uri = format!("/greengrass/definition/subscriptions/{subscription_definition_id}/versions/{subscription_definition_version_id}", subscription_definition_id = input.subscription_definition_id, subscription_definition_version_id = input.subscription_definition_version_id);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetSubscriptionDefinitionVersionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetSubscriptionDefinitionVersionError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn get_thing_runtime_configuration(
&self,
input: GetThingRuntimeConfigurationRequest,
) -> Result<GetThingRuntimeConfigurationResponse, RusotoError<GetThingRuntimeConfigurationError>>
{
let request_uri = format!(
"/greengrass/things/{thing_name}/runtimeconfig",
thing_name = input.thing_name
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetThingRuntimeConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetThingRuntimeConfigurationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_bulk_deployment_detailed_reports(
&self,
input: ListBulkDeploymentDetailedReportsRequest,
) -> Result<
ListBulkDeploymentDetailedReportsResponse,
RusotoError<ListBulkDeploymentDetailedReportsError>,
> {
let request_uri = format!(
"/greengrass/bulk/deployments/{bulk_deployment_id}/detailed-reports",
bulk_deployment_id = input.bulk_deployment_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("MaxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListBulkDeploymentDetailedReportsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListBulkDeploymentDetailedReportsError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn list_bulk_deployments(
&self,
input: ListBulkDeploymentsRequest,
) -> Result<ListBulkDeploymentsResponse, RusotoError<ListBulkDeploymentsError>> {
let request_uri = "/greengrass/bulk/deployments";
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("MaxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListBulkDeploymentsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListBulkDeploymentsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_connector_definition_versions(
&self,
input: ListConnectorDefinitionVersionsRequest,
) -> Result<
ListConnectorDefinitionVersionsResponse,
RusotoError<ListConnectorDefinitionVersionsError>,
> {
let request_uri = format!(
"/greengrass/definition/connectors/{connector_definition_id}/versions",
connector_definition_id = input.connector_definition_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("MaxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListConnectorDefinitionVersionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListConnectorDefinitionVersionsError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn list_connector_definitions(
&self,
input: ListConnectorDefinitionsRequest,
) -> Result<ListConnectorDefinitionsResponse, RusotoError<ListConnectorDefinitionsError>> {
let request_uri = "/greengrass/definition/connectors";
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("MaxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListConnectorDefinitionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListConnectorDefinitionsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_core_definition_versions(
&self,
input: ListCoreDefinitionVersionsRequest,
) -> Result<ListCoreDefinitionVersionsResponse, RusotoError<ListCoreDefinitionVersionsError>>
{
let request_uri = format!(
"/greengrass/definition/cores/{core_definition_id}/versions",
core_definition_id = input.core_definition_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("MaxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListCoreDefinitionVersionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListCoreDefinitionVersionsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_core_definitions(
&self,
input: ListCoreDefinitionsRequest,
) -> Result<ListCoreDefinitionsResponse, RusotoError<ListCoreDefinitionsError>> {
let request_uri = "/greengrass/definition/cores";
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("MaxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListCoreDefinitionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListCoreDefinitionsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_deployments(
&self,
input: ListDeploymentsRequest,
) -> Result<ListDeploymentsResponse, RusotoError<ListDeploymentsError>> {
let request_uri = format!(
"/greengrass/groups/{group_id}/deployments",
group_id = input.group_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("MaxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListDeploymentsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListDeploymentsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_device_definition_versions(
&self,
input: ListDeviceDefinitionVersionsRequest,
) -> Result<ListDeviceDefinitionVersionsResponse, RusotoError<ListDeviceDefinitionVersionsError>>
{
let request_uri = format!(
"/greengrass/definition/devices/{device_definition_id}/versions",
device_definition_id = input.device_definition_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("MaxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListDeviceDefinitionVersionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListDeviceDefinitionVersionsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_device_definitions(
&self,
input: ListDeviceDefinitionsRequest,
) -> Result<ListDeviceDefinitionsResponse, RusotoError<ListDeviceDefinitionsError>> {
let request_uri = "/greengrass/definition/devices";
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("MaxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListDeviceDefinitionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListDeviceDefinitionsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_function_definition_versions(
&self,
input: ListFunctionDefinitionVersionsRequest,
) -> Result<
ListFunctionDefinitionVersionsResponse,
RusotoError<ListFunctionDefinitionVersionsError>,
> {
let request_uri = format!(
"/greengrass/definition/functions/{function_definition_id}/versions",
function_definition_id = input.function_definition_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("MaxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListFunctionDefinitionVersionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListFunctionDefinitionVersionsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_function_definitions(
&self,
input: ListFunctionDefinitionsRequest,
) -> Result<ListFunctionDefinitionsResponse, RusotoError<ListFunctionDefinitionsError>> {
let request_uri = "/greengrass/definition/functions";
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("MaxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListFunctionDefinitionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListFunctionDefinitionsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_group_certificate_authorities(
&self,
input: ListGroupCertificateAuthoritiesRequest,
) -> Result<
ListGroupCertificateAuthoritiesResponse,
RusotoError<ListGroupCertificateAuthoritiesError>,
> {
let request_uri = format!(
"/greengrass/groups/{group_id}/certificateauthorities",
group_id = input.group_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListGroupCertificateAuthoritiesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListGroupCertificateAuthoritiesError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn list_group_versions(
&self,
input: ListGroupVersionsRequest,
) -> Result<ListGroupVersionsResponse, RusotoError<ListGroupVersionsError>> {
let request_uri = format!(
"/greengrass/groups/{group_id}/versions",
group_id = input.group_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("MaxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListGroupVersionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListGroupVersionsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_groups(
&self,
input: ListGroupsRequest,
) -> Result<ListGroupsResponse, RusotoError<ListGroupsError>> {
let request_uri = "/greengrass/groups";
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("MaxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListGroupsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListGroupsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_logger_definition_versions(
&self,
input: ListLoggerDefinitionVersionsRequest,
) -> Result<ListLoggerDefinitionVersionsResponse, RusotoError<ListLoggerDefinitionVersionsError>>
{
let request_uri = format!(
"/greengrass/definition/loggers/{logger_definition_id}/versions",
logger_definition_id = input.logger_definition_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("MaxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListLoggerDefinitionVersionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListLoggerDefinitionVersionsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_logger_definitions(
&self,
input: ListLoggerDefinitionsRequest,
) -> Result<ListLoggerDefinitionsResponse, RusotoError<ListLoggerDefinitionsError>> {
let request_uri = "/greengrass/definition/loggers";
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("MaxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListLoggerDefinitionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListLoggerDefinitionsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_resource_definition_versions(
&self,
input: ListResourceDefinitionVersionsRequest,
) -> Result<
ListResourceDefinitionVersionsResponse,
RusotoError<ListResourceDefinitionVersionsError>,
> {
let request_uri = format!(
"/greengrass/definition/resources/{resource_definition_id}/versions",
resource_definition_id = input.resource_definition_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("MaxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListResourceDefinitionVersionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListResourceDefinitionVersionsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_resource_definitions(
&self,
input: ListResourceDefinitionsRequest,
) -> Result<ListResourceDefinitionsResponse, RusotoError<ListResourceDefinitionsError>> {
let request_uri = "/greengrass/definition/resources";
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("MaxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListResourceDefinitionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListResourceDefinitionsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_subscription_definition_versions(
&self,
input: ListSubscriptionDefinitionVersionsRequest,
) -> Result<
ListSubscriptionDefinitionVersionsResponse,
RusotoError<ListSubscriptionDefinitionVersionsError>,
> {
let request_uri = format!(
"/greengrass/definition/subscriptions/{subscription_definition_id}/versions",
subscription_definition_id = input.subscription_definition_id
);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("MaxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListSubscriptionDefinitionVersionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListSubscriptionDefinitionVersionsError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn list_subscription_definitions(
&self,
input: ListSubscriptionDefinitionsRequest,
) -> Result<ListSubscriptionDefinitionsResponse, RusotoError<ListSubscriptionDefinitionsError>>
{
let request_uri = "/greengrass/definition/subscriptions";
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("MaxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("NextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListSubscriptionDefinitionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListSubscriptionDefinitionsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("GET", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListTagsForResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListTagsForResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn reset_deployments(
&self,
input: ResetDeploymentsRequest,
) -> Result<ResetDeploymentsResponse, RusotoError<ResetDeploymentsError>> {
let request_uri = format!(
"/greengrass/groups/{group_id}/deployments/$reset",
group_id = input.group_id
);
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("X-Amzn-Client-Token", input.amzn_client_token.as_ref());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ResetDeploymentsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ResetDeploymentsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn start_bulk_deployment(
&self,
input: StartBulkDeploymentRequest,
) -> Result<StartBulkDeploymentResponse, RusotoError<StartBulkDeploymentError>> {
let request_uri = "/greengrass/bulk/deployments";
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("X-Amzn-Client-Token", input.amzn_client_token.as_ref());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<StartBulkDeploymentResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(StartBulkDeploymentError::from_response(response))
}
}
#[allow(unused_mut)]
async fn stop_bulk_deployment(
&self,
input: StopBulkDeploymentRequest,
) -> Result<StopBulkDeploymentResponse, RusotoError<StopBulkDeploymentError>> {
let request_uri = format!(
"/greengrass/bulk/deployments/{bulk_deployment_id}/$stop",
bulk_deployment_id = input.bulk_deployment_id
);
let mut request = SignedRequest::new("PUT", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<StopBulkDeploymentResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(StopBulkDeploymentError::from_response(response))
}
}
#[allow(unused_mut)]
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<(), RusotoError<TagResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("POST", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(TagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<(), RusotoError<UntagResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("DELETE", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
for item in input.tag_keys.iter() {
params.put("tagKeys", item);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UntagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_connectivity_info(
&self,
input: UpdateConnectivityInfoRequest,
) -> Result<UpdateConnectivityInfoResponse, RusotoError<UpdateConnectivityInfoError>> {
let request_uri = format!(
"/greengrass/things/{thing_name}/connectivityInfo",
thing_name = input.thing_name
);
let mut request = SignedRequest::new("PUT", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateConnectivityInfoResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateConnectivityInfoError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_connector_definition(
&self,
input: UpdateConnectorDefinitionRequest,
) -> Result<UpdateConnectorDefinitionResponse, RusotoError<UpdateConnectorDefinitionError>>
{
let request_uri = format!(
"/greengrass/definition/connectors/{connector_definition_id}",
connector_definition_id = input.connector_definition_id
);
let mut request = SignedRequest::new("PUT", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateConnectorDefinitionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateConnectorDefinitionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_core_definition(
&self,
input: UpdateCoreDefinitionRequest,
) -> Result<UpdateCoreDefinitionResponse, RusotoError<UpdateCoreDefinitionError>> {
let request_uri = format!(
"/greengrass/definition/cores/{core_definition_id}",
core_definition_id = input.core_definition_id
);
let mut request = SignedRequest::new("PUT", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateCoreDefinitionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateCoreDefinitionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_device_definition(
&self,
input: UpdateDeviceDefinitionRequest,
) -> Result<UpdateDeviceDefinitionResponse, RusotoError<UpdateDeviceDefinitionError>> {
let request_uri = format!(
"/greengrass/definition/devices/{device_definition_id}",
device_definition_id = input.device_definition_id
);
let mut request = SignedRequest::new("PUT", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateDeviceDefinitionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateDeviceDefinitionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_function_definition(
&self,
input: UpdateFunctionDefinitionRequest,
) -> Result<UpdateFunctionDefinitionResponse, RusotoError<UpdateFunctionDefinitionError>> {
let request_uri = format!(
"/greengrass/definition/functions/{function_definition_id}",
function_definition_id = input.function_definition_id
);
let mut request = SignedRequest::new("PUT", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateFunctionDefinitionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateFunctionDefinitionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_group(
&self,
input: UpdateGroupRequest,
) -> Result<UpdateGroupResponse, RusotoError<UpdateGroupError>> {
let request_uri = format!("/greengrass/groups/{group_id}", group_id = input.group_id);
let mut request = SignedRequest::new("PUT", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateGroupResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateGroupError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_group_certificate_configuration(
&self,
input: UpdateGroupCertificateConfigurationRequest,
) -> Result<
UpdateGroupCertificateConfigurationResponse,
RusotoError<UpdateGroupCertificateConfigurationError>,
> {
let request_uri = format!(
"/greengrass/groups/{group_id}/certificateauthorities/configuration/expiry",
group_id = input.group_id
);
let mut request = SignedRequest::new("PUT", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateGroupCertificateConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateGroupCertificateConfigurationError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn update_logger_definition(
&self,
input: UpdateLoggerDefinitionRequest,
) -> Result<UpdateLoggerDefinitionResponse, RusotoError<UpdateLoggerDefinitionError>> {
let request_uri = format!(
"/greengrass/definition/loggers/{logger_definition_id}",
logger_definition_id = input.logger_definition_id
);
let mut request = SignedRequest::new("PUT", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateLoggerDefinitionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateLoggerDefinitionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_resource_definition(
&self,
input: UpdateResourceDefinitionRequest,
) -> Result<UpdateResourceDefinitionResponse, RusotoError<UpdateResourceDefinitionError>> {
let request_uri = format!(
"/greengrass/definition/resources/{resource_definition_id}",
resource_definition_id = input.resource_definition_id
);
let mut request = SignedRequest::new("PUT", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateResourceDefinitionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateResourceDefinitionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_subscription_definition(
&self,
input: UpdateSubscriptionDefinitionRequest,
) -> Result<UpdateSubscriptionDefinitionResponse, RusotoError<UpdateSubscriptionDefinitionError>>
{
let request_uri = format!(
"/greengrass/definition/subscriptions/{subscription_definition_id}",
subscription_definition_id = input.subscription_definition_id
);
let mut request = SignedRequest::new("PUT", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateSubscriptionDefinitionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateSubscriptionDefinitionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_thing_runtime_configuration(
&self,
input: UpdateThingRuntimeConfigurationRequest,
) -> Result<
UpdateThingRuntimeConfigurationResponse,
RusotoError<UpdateThingRuntimeConfigurationError>,
> {
let request_uri = format!(
"/greengrass/things/{thing_name}/runtimeconfig",
thing_name = input.thing_name
);
let mut request = SignedRequest::new("PUT", "greengrass", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateThingRuntimeConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateThingRuntimeConfigurationError::from_response(
response,
))
}
}
}