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, Deserialize, PartialEq, Serialize)]
pub struct AddAttributesActivity {
#[serde(rename = "attributes")]
pub attributes: ::std::collections::HashMap<String, String>,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "next")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchPutMessageErrorEntry {
#[serde(rename = "errorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "errorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "messageId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchPutMessageRequest {
#[serde(rename = "channelName")]
pub channel_name: String,
#[serde(rename = "messages")]
pub messages: Vec<Message>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchPutMessageResponse {
#[serde(rename = "batchPutMessageErrorEntries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub batch_put_message_error_entries: Option<Vec<BatchPutMessageErrorEntry>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CancelPipelineReprocessingRequest {
#[serde(rename = "pipelineName")]
pub pipeline_name: String,
#[serde(rename = "reprocessingId")]
pub reprocessing_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CancelPipelineReprocessingResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Channel {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "creationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "lastUpdateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_update_time: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "retentionPeriod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retention_period: Option<RetentionPeriod>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "storage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub storage: Option<ChannelStorage>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ChannelActivity {
#[serde(rename = "channelName")]
pub channel_name: String,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "next")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ChannelStatistics {
#[serde(rename = "size")]
#[serde(skip_serializing_if = "Option::is_none")]
pub size: Option<EstimatedResourceSize>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ChannelStorage {
#[serde(rename = "customerManagedS3")]
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_managed_s3: Option<CustomerManagedChannelS3Storage>,
#[serde(rename = "serviceManagedS3")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_managed_s3: Option<ServiceManagedChannelS3Storage>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ChannelStorageSummary {
#[serde(rename = "customerManagedS3")]
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_managed_s3: Option<CustomerManagedChannelS3StorageSummary>,
#[serde(rename = "serviceManagedS3")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_managed_s3: Option<ServiceManagedChannelS3StorageSummary>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ChannelSummary {
#[serde(rename = "channelName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub channel_name: Option<String>,
#[serde(rename = "channelStorage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub channel_storage: Option<ChannelStorageSummary>,
#[serde(rename = "creationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "lastUpdateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_update_time: Option<f64>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ContainerDatasetAction {
#[serde(rename = "executionRoleArn")]
pub execution_role_arn: String,
#[serde(rename = "image")]
pub image: String,
#[serde(rename = "resourceConfiguration")]
pub resource_configuration: ResourceConfiguration,
#[serde(rename = "variables")]
#[serde(skip_serializing_if = "Option::is_none")]
pub variables: Option<Vec<Variable>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateChannelRequest {
#[serde(rename = "channelName")]
pub channel_name: String,
#[serde(rename = "channelStorage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub channel_storage: Option<ChannelStorage>,
#[serde(rename = "retentionPeriod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retention_period: Option<RetentionPeriod>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateChannelResponse {
#[serde(rename = "channelArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub channel_arn: Option<String>,
#[serde(rename = "channelName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub channel_name: Option<String>,
#[serde(rename = "retentionPeriod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retention_period: Option<RetentionPeriod>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDatasetContentRequest {
#[serde(rename = "datasetName")]
pub dataset_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDatasetContentResponse {
#[serde(rename = "versionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDatasetRequest {
#[serde(rename = "actions")]
pub actions: Vec<DatasetAction>,
#[serde(rename = "contentDeliveryRules")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_delivery_rules: Option<Vec<DatasetContentDeliveryRule>>,
#[serde(rename = "datasetName")]
pub dataset_name: String,
#[serde(rename = "retentionPeriod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retention_period: Option<RetentionPeriod>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "triggers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub triggers: Option<Vec<DatasetTrigger>>,
#[serde(rename = "versioningConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub versioning_configuration: Option<VersioningConfiguration>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDatasetResponse {
#[serde(rename = "datasetArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_arn: Option<String>,
#[serde(rename = "datasetName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_name: Option<String>,
#[serde(rename = "retentionPeriod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retention_period: Option<RetentionPeriod>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDatastoreRequest {
#[serde(rename = "datastoreName")]
pub datastore_name: String,
#[serde(rename = "datastoreStorage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub datastore_storage: Option<DatastoreStorage>,
#[serde(rename = "retentionPeriod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retention_period: Option<RetentionPeriod>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDatastoreResponse {
#[serde(rename = "datastoreArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub datastore_arn: Option<String>,
#[serde(rename = "datastoreName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub datastore_name: Option<String>,
#[serde(rename = "retentionPeriod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retention_period: Option<RetentionPeriod>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreatePipelineRequest {
#[serde(rename = "pipelineActivities")]
pub pipeline_activities: Vec<PipelineActivity>,
#[serde(rename = "pipelineName")]
pub pipeline_name: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreatePipelineResponse {
#[serde(rename = "pipelineArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pipeline_arn: Option<String>,
#[serde(rename = "pipelineName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pipeline_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CustomerManagedChannelS3Storage {
#[serde(rename = "bucket")]
pub bucket: String,
#[serde(rename = "keyPrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key_prefix: Option<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 CustomerManagedChannelS3StorageSummary {
#[serde(rename = "bucket")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bucket: Option<String>,
#[serde(rename = "keyPrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key_prefix: Option<String>,
#[serde(rename = "roleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CustomerManagedDatastoreS3Storage {
#[serde(rename = "bucket")]
pub bucket: String,
#[serde(rename = "keyPrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key_prefix: Option<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 CustomerManagedDatastoreS3StorageSummary {
#[serde(rename = "bucket")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bucket: Option<String>,
#[serde(rename = "keyPrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key_prefix: Option<String>,
#[serde(rename = "roleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Dataset {
#[serde(rename = "actions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub actions: Option<Vec<DatasetAction>>,
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "contentDeliveryRules")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_delivery_rules: Option<Vec<DatasetContentDeliveryRule>>,
#[serde(rename = "creationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "lastUpdateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_update_time: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "retentionPeriod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retention_period: Option<RetentionPeriod>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "triggers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub triggers: Option<Vec<DatasetTrigger>>,
#[serde(rename = "versioningConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub versioning_configuration: Option<VersioningConfiguration>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DatasetAction {
#[serde(rename = "actionName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub action_name: Option<String>,
#[serde(rename = "containerAction")]
#[serde(skip_serializing_if = "Option::is_none")]
pub container_action: Option<ContainerDatasetAction>,
#[serde(rename = "queryAction")]
#[serde(skip_serializing_if = "Option::is_none")]
pub query_action: Option<SqlQueryDatasetAction>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DatasetActionSummary {
#[serde(rename = "actionName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub action_name: Option<String>,
#[serde(rename = "actionType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub action_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DatasetContentDeliveryDestination {
#[serde(rename = "iotEventsDestinationConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iot_events_destination_configuration: Option<IotEventsDestinationConfiguration>,
#[serde(rename = "s3DestinationConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s_3_destination_configuration: Option<S3DestinationConfiguration>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DatasetContentDeliveryRule {
#[serde(rename = "destination")]
pub destination: DatasetContentDeliveryDestination,
#[serde(rename = "entryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub entry_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DatasetContentStatus {
#[serde(rename = "reason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reason: Option<String>,
#[serde(rename = "state")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DatasetContentSummary {
#[serde(rename = "completionTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub completion_time: Option<f64>,
#[serde(rename = "creationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "scheduleTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schedule_time: Option<f64>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<DatasetContentStatus>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DatasetContentVersionValue {
#[serde(rename = "datasetName")]
pub dataset_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DatasetEntry {
#[serde(rename = "dataURI")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_uri: Option<String>,
#[serde(rename = "entryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub entry_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DatasetSummary {
#[serde(rename = "actions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub actions: Option<Vec<DatasetActionSummary>>,
#[serde(rename = "creationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "datasetName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_name: Option<String>,
#[serde(rename = "lastUpdateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_update_time: Option<f64>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "triggers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub triggers: Option<Vec<DatasetTrigger>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DatasetTrigger {
#[serde(rename = "dataset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset: Option<TriggeringDataset>,
#[serde(rename = "schedule")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schedule: Option<Schedule>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Datastore {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "creationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "lastUpdateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_update_time: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "retentionPeriod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retention_period: Option<RetentionPeriod>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "storage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub storage: Option<DatastoreStorage>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DatastoreActivity {
#[serde(rename = "datastoreName")]
pub datastore_name: String,
#[serde(rename = "name")]
pub name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DatastoreStatistics {
#[serde(rename = "size")]
#[serde(skip_serializing_if = "Option::is_none")]
pub size: Option<EstimatedResourceSize>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DatastoreStorage {
#[serde(rename = "customerManagedS3")]
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_managed_s3: Option<CustomerManagedDatastoreS3Storage>,
#[serde(rename = "serviceManagedS3")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_managed_s3: Option<ServiceManagedDatastoreS3Storage>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DatastoreStorageSummary {
#[serde(rename = "customerManagedS3")]
#[serde(skip_serializing_if = "Option::is_none")]
pub customer_managed_s3: Option<CustomerManagedDatastoreS3StorageSummary>,
#[serde(rename = "serviceManagedS3")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_managed_s3: Option<ServiceManagedDatastoreS3StorageSummary>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DatastoreSummary {
#[serde(rename = "creationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "datastoreName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub datastore_name: Option<String>,
#[serde(rename = "datastoreStorage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub datastore_storage: Option<DatastoreStorageSummary>,
#[serde(rename = "lastUpdateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_update_time: Option<f64>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteChannelRequest {
#[serde(rename = "channelName")]
pub channel_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDatasetContentRequest {
#[serde(rename = "datasetName")]
pub dataset_name: String,
#[serde(rename = "versionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDatasetRequest {
#[serde(rename = "datasetName")]
pub dataset_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDatastoreRequest {
#[serde(rename = "datastoreName")]
pub datastore_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeletePipelineRequest {
#[serde(rename = "pipelineName")]
pub pipeline_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DeltaTime {
#[serde(rename = "offsetSeconds")]
pub offset_seconds: i64,
#[serde(rename = "timeExpression")]
pub time_expression: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeChannelRequest {
#[serde(rename = "channelName")]
pub channel_name: String,
#[serde(rename = "includeStatistics")]
#[serde(skip_serializing_if = "Option::is_none")]
pub include_statistics: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeChannelResponse {
#[serde(rename = "channel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub channel: Option<Channel>,
#[serde(rename = "statistics")]
#[serde(skip_serializing_if = "Option::is_none")]
pub statistics: Option<ChannelStatistics>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeDatasetRequest {
#[serde(rename = "datasetName")]
pub dataset_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeDatasetResponse {
#[serde(rename = "dataset")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset: Option<Dataset>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeDatastoreRequest {
#[serde(rename = "datastoreName")]
pub datastore_name: String,
#[serde(rename = "includeStatistics")]
#[serde(skip_serializing_if = "Option::is_none")]
pub include_statistics: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeDatastoreResponse {
#[serde(rename = "datastore")]
#[serde(skip_serializing_if = "Option::is_none")]
pub datastore: Option<Datastore>,
#[serde(rename = "statistics")]
#[serde(skip_serializing_if = "Option::is_none")]
pub statistics: Option<DatastoreStatistics>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeLoggingOptionsRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeLoggingOptionsResponse {
#[serde(rename = "loggingOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub logging_options: Option<LoggingOptions>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribePipelineRequest {
#[serde(rename = "pipelineName")]
pub pipeline_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribePipelineResponse {
#[serde(rename = "pipeline")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pipeline: Option<Pipeline>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DeviceRegistryEnrichActivity {
#[serde(rename = "attribute")]
pub attribute: String,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "next")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next: Option<String>,
#[serde(rename = "roleArn")]
pub role_arn: String,
#[serde(rename = "thingName")]
pub thing_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DeviceShadowEnrichActivity {
#[serde(rename = "attribute")]
pub attribute: String,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "next")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next: Option<String>,
#[serde(rename = "roleArn")]
pub role_arn: String,
#[serde(rename = "thingName")]
pub thing_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EstimatedResourceSize {
#[serde(rename = "estimatedOn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub estimated_on: Option<f64>,
#[serde(rename = "estimatedSizeInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub estimated_size_in_bytes: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct FilterActivity {
#[serde(rename = "filter")]
pub filter: String,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "next")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDatasetContentRequest {
#[serde(rename = "datasetName")]
pub dataset_name: String,
#[serde(rename = "versionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDatasetContentResponse {
#[serde(rename = "entries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub entries: Option<Vec<DatasetEntry>>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<DatasetContentStatus>,
#[serde(rename = "timestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timestamp: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct GlueConfiguration {
#[serde(rename = "databaseName")]
pub database_name: String,
#[serde(rename = "tableName")]
pub table_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct IotEventsDestinationConfiguration {
#[serde(rename = "inputName")]
pub input_name: String,
#[serde(rename = "roleArn")]
pub role_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct LambdaActivity {
#[serde(rename = "batchSize")]
pub batch_size: i64,
#[serde(rename = "lambdaName")]
pub lambda_name: String,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "next")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListChannelsRequest {
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListChannelsResponse {
#[serde(rename = "channelSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub channel_summaries: Option<Vec<ChannelSummary>>,
#[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 ListDatasetContentsRequest {
#[serde(rename = "datasetName")]
pub dataset_name: String,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "scheduledBefore")]
#[serde(skip_serializing_if = "Option::is_none")]
pub scheduled_before: Option<f64>,
#[serde(rename = "scheduledOnOrAfter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub scheduled_on_or_after: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDatasetContentsResponse {
#[serde(rename = "datasetContentSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_content_summaries: Option<Vec<DatasetContentSummary>>,
#[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 ListDatasetsRequest {
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDatasetsResponse {
#[serde(rename = "datasetSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_summaries: Option<Vec<DatasetSummary>>,
#[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 ListDatastoresRequest {
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDatastoresResponse {
#[serde(rename = "datastoreSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub datastore_summaries: Option<Vec<DatastoreSummary>>,
#[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 ListPipelinesRequest {
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListPipelinesResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "pipelineSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pipeline_summaries: Option<Vec<PipelineSummary>>,
}
#[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<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct LoggingOptions {
#[serde(rename = "enabled")]
pub enabled: bool,
#[serde(rename = "level")]
pub level: String,
#[serde(rename = "roleArn")]
pub role_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct MathActivity {
#[serde(rename = "attribute")]
pub attribute: String,
#[serde(rename = "math")]
pub math: String,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "next")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Message {
#[serde(rename = "messageId")]
pub message_id: String,
#[serde(rename = "payload")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlob::deserialize_blob",
serialize_with = "::rusoto_core::serialization::SerdeBlob::serialize_blob",
default
)]
pub payload: bytes::Bytes,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct OutputFileUriValue {
#[serde(rename = "fileName")]
pub file_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Pipeline {
#[serde(rename = "activities")]
#[serde(skip_serializing_if = "Option::is_none")]
pub activities: Option<Vec<PipelineActivity>>,
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "creationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "lastUpdateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_update_time: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "reprocessingSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reprocessing_summaries: Option<Vec<ReprocessingSummary>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct PipelineActivity {
#[serde(rename = "addAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub add_attributes: Option<AddAttributesActivity>,
#[serde(rename = "channel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub channel: Option<ChannelActivity>,
#[serde(rename = "datastore")]
#[serde(skip_serializing_if = "Option::is_none")]
pub datastore: Option<DatastoreActivity>,
#[serde(rename = "deviceRegistryEnrich")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_registry_enrich: Option<DeviceRegistryEnrichActivity>,
#[serde(rename = "deviceShadowEnrich")]
#[serde(skip_serializing_if = "Option::is_none")]
pub device_shadow_enrich: Option<DeviceShadowEnrichActivity>,
#[serde(rename = "filter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter: Option<FilterActivity>,
#[serde(rename = "lambda")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lambda: Option<LambdaActivity>,
#[serde(rename = "math")]
#[serde(skip_serializing_if = "Option::is_none")]
pub math: Option<MathActivity>,
#[serde(rename = "removeAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remove_attributes: Option<RemoveAttributesActivity>,
#[serde(rename = "selectAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub select_attributes: Option<SelectAttributesActivity>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PipelineSummary {
#[serde(rename = "creationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "lastUpdateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_update_time: Option<f64>,
#[serde(rename = "pipelineName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pipeline_name: Option<String>,
#[serde(rename = "reprocessingSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reprocessing_summaries: Option<Vec<ReprocessingSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutLoggingOptionsRequest {
#[serde(rename = "loggingOptions")]
pub logging_options: LoggingOptions,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct QueryFilter {
#[serde(rename = "deltaTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delta_time: Option<DeltaTime>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct RemoveAttributesActivity {
#[serde(rename = "attributes")]
pub attributes: Vec<String>,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "next")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ReprocessingSummary {
#[serde(rename = "creationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ResourceConfiguration {
#[serde(rename = "computeType")]
pub compute_type: String,
#[serde(rename = "volumeSizeInGB")]
pub volume_size_in_gb: i64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct RetentionPeriod {
#[serde(rename = "numberOfDays")]
#[serde(skip_serializing_if = "Option::is_none")]
pub number_of_days: Option<i64>,
#[serde(rename = "unlimited")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unlimited: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RunPipelineActivityRequest {
#[serde(rename = "payloads")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlobList::deserialize_blob_list",
serialize_with = "::rusoto_core::serialization::SerdeBlobList::serialize_blob_list",
default
)]
pub payloads: Vec<bytes::Bytes>,
#[serde(rename = "pipelineActivity")]
pub pipeline_activity: PipelineActivity,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RunPipelineActivityResponse {
#[serde(rename = "logResult")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_result: Option<String>,
#[serde(rename = "payloads")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlobList::deserialize_blob_list",
serialize_with = "::rusoto_core::serialization::SerdeBlobList::serialize_blob_list",
default
)]
#[serde(skip_serializing_if = "Option::is_none")]
pub payloads: Option<Vec<bytes::Bytes>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct S3DestinationConfiguration {
#[serde(rename = "bucket")]
pub bucket: String,
#[serde(rename = "glueConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub glue_configuration: Option<GlueConfiguration>,
#[serde(rename = "key")]
pub key: String,
#[serde(rename = "roleArn")]
pub role_arn: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SampleChannelDataRequest {
#[serde(rename = "channelName")]
pub channel_name: String,
#[serde(rename = "endTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_time: Option<f64>,
#[serde(rename = "maxMessages")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_messages: Option<i64>,
#[serde(rename = "startTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SampleChannelDataResponse {
#[serde(rename = "payloads")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlobList::deserialize_blob_list",
serialize_with = "::rusoto_core::serialization::SerdeBlobList::serialize_blob_list",
default
)]
#[serde(skip_serializing_if = "Option::is_none")]
pub payloads: Option<Vec<bytes::Bytes>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Schedule {
#[serde(rename = "expression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expression: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SelectAttributesActivity {
#[serde(rename = "attributes")]
pub attributes: Vec<String>,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "next")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ServiceManagedChannelS3Storage {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ServiceManagedChannelS3StorageSummary {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ServiceManagedDatastoreS3Storage {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ServiceManagedDatastoreS3StorageSummary {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SqlQueryDatasetAction {
#[serde(rename = "filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<QueryFilter>>,
#[serde(rename = "sqlQuery")]
pub sql_query: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartPipelineReprocessingRequest {
#[serde(rename = "endTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_time: Option<f64>,
#[serde(rename = "pipelineName")]
pub pipeline_name: String,
#[serde(rename = "startTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartPipelineReprocessingResponse {
#[serde(rename = "reprocessingId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reprocessing_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Tag {
#[serde(rename = "key")]
pub key: String,
#[serde(rename = "value")]
pub value: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "resourceArn")]
pub resource_arn: String,
#[serde(rename = "tags")]
pub tags: Vec<Tag>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TagResourceResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TriggeringDataset {
#[serde(rename = "name")]
pub name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
#[serde(rename = "resourceArn")]
pub resource_arn: String,
#[serde(rename = "tagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UntagResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateChannelRequest {
#[serde(rename = "channelName")]
pub channel_name: String,
#[serde(rename = "channelStorage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub channel_storage: Option<ChannelStorage>,
#[serde(rename = "retentionPeriod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retention_period: Option<RetentionPeriod>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateDatasetRequest {
#[serde(rename = "actions")]
pub actions: Vec<DatasetAction>,
#[serde(rename = "contentDeliveryRules")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_delivery_rules: Option<Vec<DatasetContentDeliveryRule>>,
#[serde(rename = "datasetName")]
pub dataset_name: String,
#[serde(rename = "retentionPeriod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retention_period: Option<RetentionPeriod>,
#[serde(rename = "triggers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub triggers: Option<Vec<DatasetTrigger>>,
#[serde(rename = "versioningConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub versioning_configuration: Option<VersioningConfiguration>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateDatastoreRequest {
#[serde(rename = "datastoreName")]
pub datastore_name: String,
#[serde(rename = "datastoreStorage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub datastore_storage: Option<DatastoreStorage>,
#[serde(rename = "retentionPeriod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retention_period: Option<RetentionPeriod>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdatePipelineRequest {
#[serde(rename = "pipelineActivities")]
pub pipeline_activities: Vec<PipelineActivity>,
#[serde(rename = "pipelineName")]
pub pipeline_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Variable {
#[serde(rename = "datasetContentVersionValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dataset_content_version_value: Option<DatasetContentVersionValue>,
#[serde(rename = "doubleValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub double_value: Option<f64>,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "outputFileUriValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_file_uri_value: Option<OutputFileUriValue>,
#[serde(rename = "stringValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub string_value: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct VersioningConfiguration {
#[serde(rename = "maxVersions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_versions: Option<i64>,
#[serde(rename = "unlimited")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unlimited: Option<bool>,
}
#[derive(Debug, PartialEq)]
pub enum BatchPutMessageError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl BatchPutMessageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<BatchPutMessageError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(BatchPutMessageError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(BatchPutMessageError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(BatchPutMessageError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(BatchPutMessageError::ServiceUnavailable(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(BatchPutMessageError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BatchPutMessageError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchPutMessageError::InternalFailure(ref cause) => write!(f, "{}", cause),
BatchPutMessageError::InvalidRequest(ref cause) => write!(f, "{}", cause),
BatchPutMessageError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
BatchPutMessageError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
BatchPutMessageError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for BatchPutMessageError {}
#[derive(Debug, PartialEq)]
pub enum CancelPipelineReprocessingError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl CancelPipelineReprocessingError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CancelPipelineReprocessingError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(CancelPipelineReprocessingError::InternalFailure(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(CancelPipelineReprocessingError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CancelPipelineReprocessingError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(
CancelPipelineReprocessingError::ServiceUnavailable(err.msg),
)
}
"ThrottlingException" => {
return RusotoError::Service(CancelPipelineReprocessingError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CancelPipelineReprocessingError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CancelPipelineReprocessingError::InternalFailure(ref cause) => write!(f, "{}", cause),
CancelPipelineReprocessingError::InvalidRequest(ref cause) => write!(f, "{}", cause),
CancelPipelineReprocessingError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CancelPipelineReprocessingError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
CancelPipelineReprocessingError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CancelPipelineReprocessingError {}
#[derive(Debug, PartialEq)]
pub enum CreateChannelError {
InternalFailure(String),
InvalidRequest(String),
LimitExceeded(String),
ResourceAlreadyExists(String),
ServiceUnavailable(String),
Throttling(String),
}
impl CreateChannelError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateChannelError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(CreateChannelError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateChannelError::InvalidRequest(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateChannelError::LimitExceeded(err.msg))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(CreateChannelError::ResourceAlreadyExists(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(CreateChannelError::ServiceUnavailable(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(CreateChannelError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateChannelError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateChannelError::InternalFailure(ref cause) => write!(f, "{}", cause),
CreateChannelError::InvalidRequest(ref cause) => write!(f, "{}", cause),
CreateChannelError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateChannelError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateChannelError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
CreateChannelError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateChannelError {}
#[derive(Debug, PartialEq)]
pub enum CreateDatasetError {
InternalFailure(String),
InvalidRequest(String),
LimitExceeded(String),
ResourceAlreadyExists(String),
ServiceUnavailable(String),
Throttling(String),
}
impl CreateDatasetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDatasetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(CreateDatasetError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateDatasetError::InvalidRequest(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateDatasetError::LimitExceeded(err.msg))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(CreateDatasetError::ResourceAlreadyExists(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(CreateDatasetError::ServiceUnavailable(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(CreateDatasetError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDatasetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDatasetError::InternalFailure(ref cause) => write!(f, "{}", cause),
CreateDatasetError::InvalidRequest(ref cause) => write!(f, "{}", cause),
CreateDatasetError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateDatasetError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateDatasetError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
CreateDatasetError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDatasetError {}
#[derive(Debug, PartialEq)]
pub enum CreateDatasetContentError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl CreateDatasetContentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDatasetContentError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(CreateDatasetContentError::InternalFailure(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateDatasetContentError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateDatasetContentError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(CreateDatasetContentError::ServiceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(CreateDatasetContentError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDatasetContentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDatasetContentError::InternalFailure(ref cause) => write!(f, "{}", cause),
CreateDatasetContentError::InvalidRequest(ref cause) => write!(f, "{}", cause),
CreateDatasetContentError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateDatasetContentError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
CreateDatasetContentError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDatasetContentError {}
#[derive(Debug, PartialEq)]
pub enum CreateDatastoreError {
InternalFailure(String),
InvalidRequest(String),
LimitExceeded(String),
ResourceAlreadyExists(String),
ServiceUnavailable(String),
Throttling(String),
}
impl CreateDatastoreError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDatastoreError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(CreateDatastoreError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CreateDatastoreError::InvalidRequest(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateDatastoreError::LimitExceeded(err.msg))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(CreateDatastoreError::ResourceAlreadyExists(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(CreateDatastoreError::ServiceUnavailable(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(CreateDatastoreError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDatastoreError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDatastoreError::InternalFailure(ref cause) => write!(f, "{}", cause),
CreateDatastoreError::InvalidRequest(ref cause) => write!(f, "{}", cause),
CreateDatastoreError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateDatastoreError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateDatastoreError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
CreateDatastoreError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDatastoreError {}
#[derive(Debug, PartialEq)]
pub enum CreatePipelineError {
InternalFailure(String),
InvalidRequest(String),
LimitExceeded(String),
ResourceAlreadyExists(String),
ServiceUnavailable(String),
Throttling(String),
}
impl CreatePipelineError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreatePipelineError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(CreatePipelineError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(CreatePipelineError::InvalidRequest(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreatePipelineError::LimitExceeded(err.msg))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(CreatePipelineError::ResourceAlreadyExists(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(CreatePipelineError::ServiceUnavailable(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(CreatePipelineError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreatePipelineError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreatePipelineError::InternalFailure(ref cause) => write!(f, "{}", cause),
CreatePipelineError::InvalidRequest(ref cause) => write!(f, "{}", cause),
CreatePipelineError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreatePipelineError::ResourceAlreadyExists(ref cause) => write!(f, "{}", cause),
CreatePipelineError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
CreatePipelineError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreatePipelineError {}
#[derive(Debug, PartialEq)]
pub enum DeleteChannelError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl DeleteChannelError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteChannelError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(DeleteChannelError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteChannelError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteChannelError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DeleteChannelError::ServiceUnavailable(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DeleteChannelError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteChannelError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteChannelError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeleteChannelError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeleteChannelError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteChannelError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
DeleteChannelError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteChannelError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDatasetError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl DeleteDatasetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDatasetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(DeleteDatasetError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteDatasetError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteDatasetError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DeleteDatasetError::ServiceUnavailable(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DeleteDatasetError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDatasetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDatasetError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeleteDatasetError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeleteDatasetError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteDatasetError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
DeleteDatasetError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDatasetError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDatasetContentError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl DeleteDatasetContentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDatasetContentError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(DeleteDatasetContentError::InternalFailure(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteDatasetContentError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteDatasetContentError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DeleteDatasetContentError::ServiceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(DeleteDatasetContentError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDatasetContentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDatasetContentError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeleteDatasetContentError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeleteDatasetContentError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteDatasetContentError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
DeleteDatasetContentError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDatasetContentError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDatastoreError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl DeleteDatastoreError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDatastoreError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(DeleteDatastoreError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteDatastoreError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteDatastoreError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DeleteDatastoreError::ServiceUnavailable(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DeleteDatastoreError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDatastoreError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDatastoreError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeleteDatastoreError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeleteDatastoreError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteDatastoreError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
DeleteDatastoreError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDatastoreError {}
#[derive(Debug, PartialEq)]
pub enum DeletePipelineError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl DeletePipelineError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeletePipelineError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(DeletePipelineError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DeletePipelineError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeletePipelineError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DeletePipelineError::ServiceUnavailable(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DeletePipelineError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeletePipelineError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeletePipelineError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeletePipelineError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeletePipelineError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeletePipelineError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
DeletePipelineError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeletePipelineError {}
#[derive(Debug, PartialEq)]
pub enum DescribeChannelError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl DescribeChannelError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeChannelError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(DescribeChannelError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DescribeChannelError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeChannelError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DescribeChannelError::ServiceUnavailable(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DescribeChannelError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeChannelError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeChannelError::InternalFailure(ref cause) => write!(f, "{}", cause),
DescribeChannelError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DescribeChannelError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeChannelError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
DescribeChannelError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeChannelError {}
#[derive(Debug, PartialEq)]
pub enum DescribeDatasetError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl DescribeDatasetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeDatasetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(DescribeDatasetError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DescribeDatasetError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeDatasetError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DescribeDatasetError::ServiceUnavailable(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DescribeDatasetError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeDatasetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeDatasetError::InternalFailure(ref cause) => write!(f, "{}", cause),
DescribeDatasetError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DescribeDatasetError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeDatasetError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
DescribeDatasetError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeDatasetError {}
#[derive(Debug, PartialEq)]
pub enum DescribeDatastoreError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl DescribeDatastoreError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeDatastoreError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(DescribeDatastoreError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DescribeDatastoreError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeDatastoreError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DescribeDatastoreError::ServiceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(DescribeDatastoreError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeDatastoreError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeDatastoreError::InternalFailure(ref cause) => write!(f, "{}", cause),
DescribeDatastoreError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DescribeDatastoreError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeDatastoreError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
DescribeDatastoreError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeDatastoreError {}
#[derive(Debug, PartialEq)]
pub enum DescribeLoggingOptionsError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl DescribeLoggingOptionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeLoggingOptionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(DescribeLoggingOptionsError::InternalFailure(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(DescribeLoggingOptionsError::InvalidRequest(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeLoggingOptionsError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DescribeLoggingOptionsError::ServiceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(DescribeLoggingOptionsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeLoggingOptionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeLoggingOptionsError::InternalFailure(ref cause) => write!(f, "{}", cause),
DescribeLoggingOptionsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DescribeLoggingOptionsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeLoggingOptionsError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
DescribeLoggingOptionsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeLoggingOptionsError {}
#[derive(Debug, PartialEq)]
pub enum DescribePipelineError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl DescribePipelineError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribePipelineError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(DescribePipelineError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(DescribePipelineError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribePipelineError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DescribePipelineError::ServiceUnavailable(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(DescribePipelineError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribePipelineError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribePipelineError::InternalFailure(ref cause) => write!(f, "{}", cause),
DescribePipelineError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DescribePipelineError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribePipelineError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
DescribePipelineError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribePipelineError {}
#[derive(Debug, PartialEq)]
pub enum GetDatasetContentError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl GetDatasetContentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDatasetContentError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(GetDatasetContentError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(GetDatasetContentError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetDatasetContentError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(GetDatasetContentError::ServiceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(GetDatasetContentError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDatasetContentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDatasetContentError::InternalFailure(ref cause) => write!(f, "{}", cause),
GetDatasetContentError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetDatasetContentError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetDatasetContentError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
GetDatasetContentError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDatasetContentError {}
#[derive(Debug, PartialEq)]
pub enum ListChannelsError {
InternalFailure(String),
InvalidRequest(String),
ServiceUnavailable(String),
Throttling(String),
}
impl ListChannelsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListChannelsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(ListChannelsError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListChannelsError::InvalidRequest(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListChannelsError::ServiceUnavailable(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(ListChannelsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListChannelsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListChannelsError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListChannelsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListChannelsError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
ListChannelsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListChannelsError {}
#[derive(Debug, PartialEq)]
pub enum ListDatasetContentsError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl ListDatasetContentsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDatasetContentsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(ListDatasetContentsError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListDatasetContentsError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListDatasetContentsError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListDatasetContentsError::ServiceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(ListDatasetContentsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDatasetContentsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDatasetContentsError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListDatasetContentsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListDatasetContentsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListDatasetContentsError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
ListDatasetContentsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDatasetContentsError {}
#[derive(Debug, PartialEq)]
pub enum ListDatasetsError {
InternalFailure(String),
InvalidRequest(String),
ServiceUnavailable(String),
Throttling(String),
}
impl ListDatasetsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDatasetsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(ListDatasetsError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListDatasetsError::InvalidRequest(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListDatasetsError::ServiceUnavailable(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(ListDatasetsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDatasetsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDatasetsError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListDatasetsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListDatasetsError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
ListDatasetsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDatasetsError {}
#[derive(Debug, PartialEq)]
pub enum ListDatastoresError {
InternalFailure(String),
InvalidRequest(String),
ServiceUnavailable(String),
Throttling(String),
}
impl ListDatastoresError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDatastoresError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(ListDatastoresError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListDatastoresError::InvalidRequest(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListDatastoresError::ServiceUnavailable(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(ListDatastoresError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDatastoresError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDatastoresError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListDatastoresError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListDatastoresError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
ListDatastoresError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDatastoresError {}
#[derive(Debug, PartialEq)]
pub enum ListPipelinesError {
InternalFailure(String),
InvalidRequest(String),
ServiceUnavailable(String),
Throttling(String),
}
impl ListPipelinesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListPipelinesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(ListPipelinesError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListPipelinesError::InvalidRequest(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListPipelinesError::ServiceUnavailable(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(ListPipelinesError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListPipelinesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListPipelinesError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListPipelinesError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListPipelinesError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
ListPipelinesError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListPipelinesError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
InternalFailure(String),
InvalidRequest(String),
LimitExceeded(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(ListTagsForResourceError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidRequest(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListTagsForResourceError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListTagsForResourceError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListTagsForResourceError::ServiceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(ListTagsForResourceError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsForResourceError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum PutLoggingOptionsError {
InternalFailure(String),
InvalidRequest(String),
ServiceUnavailable(String),
Throttling(String),
}
impl PutLoggingOptionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutLoggingOptionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(PutLoggingOptionsError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(PutLoggingOptionsError::InvalidRequest(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(PutLoggingOptionsError::ServiceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(PutLoggingOptionsError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutLoggingOptionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutLoggingOptionsError::InternalFailure(ref cause) => write!(f, "{}", cause),
PutLoggingOptionsError::InvalidRequest(ref cause) => write!(f, "{}", cause),
PutLoggingOptionsError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
PutLoggingOptionsError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutLoggingOptionsError {}
#[derive(Debug, PartialEq)]
pub enum RunPipelineActivityError {
InternalFailure(String),
InvalidRequest(String),
ServiceUnavailable(String),
Throttling(String),
}
impl RunPipelineActivityError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RunPipelineActivityError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(RunPipelineActivityError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(RunPipelineActivityError::InvalidRequest(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(RunPipelineActivityError::ServiceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(RunPipelineActivityError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RunPipelineActivityError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RunPipelineActivityError::InternalFailure(ref cause) => write!(f, "{}", cause),
RunPipelineActivityError::InvalidRequest(ref cause) => write!(f, "{}", cause),
RunPipelineActivityError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
RunPipelineActivityError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RunPipelineActivityError {}
#[derive(Debug, PartialEq)]
pub enum SampleChannelDataError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl SampleChannelDataError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SampleChannelDataError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(SampleChannelDataError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(SampleChannelDataError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(SampleChannelDataError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(SampleChannelDataError::ServiceUnavailable(
err.msg,
))
}
"ThrottlingException" => {
return RusotoError::Service(SampleChannelDataError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SampleChannelDataError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SampleChannelDataError::InternalFailure(ref cause) => write!(f, "{}", cause),
SampleChannelDataError::InvalidRequest(ref cause) => write!(f, "{}", cause),
SampleChannelDataError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
SampleChannelDataError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
SampleChannelDataError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SampleChannelDataError {}
#[derive(Debug, PartialEq)]
pub enum StartPipelineReprocessingError {
InternalFailure(String),
InvalidRequest(String),
ResourceAlreadyExists(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl StartPipelineReprocessingError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartPipelineReprocessingError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(StartPipelineReprocessingError::InternalFailure(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(StartPipelineReprocessingError::InvalidRequest(
err.msg,
))
}
"ResourceAlreadyExistsException" => {
return RusotoError::Service(
StartPipelineReprocessingError::ResourceAlreadyExists(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(StartPipelineReprocessingError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(
StartPipelineReprocessingError::ServiceUnavailable(err.msg),
)
}
"ThrottlingException" => {
return RusotoError::Service(StartPipelineReprocessingError::Throttling(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartPipelineReprocessingError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartPipelineReprocessingError::InternalFailure(ref cause) => write!(f, "{}", cause),
StartPipelineReprocessingError::InvalidRequest(ref cause) => write!(f, "{}", cause),
StartPipelineReprocessingError::ResourceAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
StartPipelineReprocessingError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
StartPipelineReprocessingError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
StartPipelineReprocessingError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartPipelineReprocessingError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
InternalFailure(String),
InvalidRequest(String),
LimitExceeded(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(TagResourceError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(TagResourceError::InvalidRequest(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(TagResourceError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(TagResourceError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(TagResourceError::ServiceUnavailable(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(TagResourceError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagResourceError::InternalFailure(ref cause) => write!(f, "{}", cause),
TagResourceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
TagResourceError::LimitExceeded(ref cause) => write!(f, "{}", cause),
TagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
TagResourceError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
TagResourceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
InternalFailure(String),
InvalidRequest(String),
LimitExceeded(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(UntagResourceError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(UntagResourceError::InvalidRequest(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(UntagResourceError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UntagResourceError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(UntagResourceError::ServiceUnavailable(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(UntagResourceError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UntagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UntagResourceError::InternalFailure(ref cause) => write!(f, "{}", cause),
UntagResourceError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UntagResourceError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UntagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UntagResourceError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
UntagResourceError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateChannelError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl UpdateChannelError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateChannelError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(UpdateChannelError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(UpdateChannelError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateChannelError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(UpdateChannelError::ServiceUnavailable(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(UpdateChannelError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateChannelError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateChannelError::InternalFailure(ref cause) => write!(f, "{}", cause),
UpdateChannelError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UpdateChannelError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateChannelError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
UpdateChannelError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateChannelError {}
#[derive(Debug, PartialEq)]
pub enum UpdateDatasetError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl UpdateDatasetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateDatasetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(UpdateDatasetError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(UpdateDatasetError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateDatasetError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(UpdateDatasetError::ServiceUnavailable(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(UpdateDatasetError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateDatasetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateDatasetError::InternalFailure(ref cause) => write!(f, "{}", cause),
UpdateDatasetError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UpdateDatasetError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateDatasetError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
UpdateDatasetError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateDatasetError {}
#[derive(Debug, PartialEq)]
pub enum UpdateDatastoreError {
InternalFailure(String),
InvalidRequest(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl UpdateDatastoreError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateDatastoreError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(UpdateDatastoreError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(UpdateDatastoreError::InvalidRequest(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateDatastoreError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(UpdateDatastoreError::ServiceUnavailable(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(UpdateDatastoreError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateDatastoreError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateDatastoreError::InternalFailure(ref cause) => write!(f, "{}", cause),
UpdateDatastoreError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UpdateDatastoreError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateDatastoreError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
UpdateDatastoreError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateDatastoreError {}
#[derive(Debug, PartialEq)]
pub enum UpdatePipelineError {
InternalFailure(String),
InvalidRequest(String),
LimitExceeded(String),
ResourceNotFound(String),
ServiceUnavailable(String),
Throttling(String),
}
impl UpdatePipelineError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdatePipelineError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InternalFailureException" => {
return RusotoError::Service(UpdatePipelineError::InternalFailure(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(UpdatePipelineError::InvalidRequest(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(UpdatePipelineError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdatePipelineError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(UpdatePipelineError::ServiceUnavailable(err.msg))
}
"ThrottlingException" => {
return RusotoError::Service(UpdatePipelineError::Throttling(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdatePipelineError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdatePipelineError::InternalFailure(ref cause) => write!(f, "{}", cause),
UpdatePipelineError::InvalidRequest(ref cause) => write!(f, "{}", cause),
UpdatePipelineError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdatePipelineError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdatePipelineError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
UpdatePipelineError::Throttling(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdatePipelineError {}
#[async_trait]
pub trait IotAnalytics {
async fn batch_put_message(
&self,
input: BatchPutMessageRequest,
) -> Result<BatchPutMessageResponse, RusotoError<BatchPutMessageError>>;
async fn cancel_pipeline_reprocessing(
&self,
input: CancelPipelineReprocessingRequest,
) -> Result<CancelPipelineReprocessingResponse, RusotoError<CancelPipelineReprocessingError>>;
async fn create_channel(
&self,
input: CreateChannelRequest,
) -> Result<CreateChannelResponse, RusotoError<CreateChannelError>>;
async fn create_dataset(
&self,
input: CreateDatasetRequest,
) -> Result<CreateDatasetResponse, RusotoError<CreateDatasetError>>;
async fn create_dataset_content(
&self,
input: CreateDatasetContentRequest,
) -> Result<CreateDatasetContentResponse, RusotoError<CreateDatasetContentError>>;
async fn create_datastore(
&self,
input: CreateDatastoreRequest,
) -> Result<CreateDatastoreResponse, RusotoError<CreateDatastoreError>>;
async fn create_pipeline(
&self,
input: CreatePipelineRequest,
) -> Result<CreatePipelineResponse, RusotoError<CreatePipelineError>>;
async fn delete_channel(
&self,
input: DeleteChannelRequest,
) -> Result<(), RusotoError<DeleteChannelError>>;
async fn delete_dataset(
&self,
input: DeleteDatasetRequest,
) -> Result<(), RusotoError<DeleteDatasetError>>;
async fn delete_dataset_content(
&self,
input: DeleteDatasetContentRequest,
) -> Result<(), RusotoError<DeleteDatasetContentError>>;
async fn delete_datastore(
&self,
input: DeleteDatastoreRequest,
) -> Result<(), RusotoError<DeleteDatastoreError>>;
async fn delete_pipeline(
&self,
input: DeletePipelineRequest,
) -> Result<(), RusotoError<DeletePipelineError>>;
async fn describe_channel(
&self,
input: DescribeChannelRequest,
) -> Result<DescribeChannelResponse, RusotoError<DescribeChannelError>>;
async fn describe_dataset(
&self,
input: DescribeDatasetRequest,
) -> Result<DescribeDatasetResponse, RusotoError<DescribeDatasetError>>;
async fn describe_datastore(
&self,
input: DescribeDatastoreRequest,
) -> Result<DescribeDatastoreResponse, RusotoError<DescribeDatastoreError>>;
async fn describe_logging_options(
&self,
) -> Result<DescribeLoggingOptionsResponse, RusotoError<DescribeLoggingOptionsError>>;
async fn describe_pipeline(
&self,
input: DescribePipelineRequest,
) -> Result<DescribePipelineResponse, RusotoError<DescribePipelineError>>;
async fn get_dataset_content(
&self,
input: GetDatasetContentRequest,
) -> Result<GetDatasetContentResponse, RusotoError<GetDatasetContentError>>;
async fn list_channels(
&self,
input: ListChannelsRequest,
) -> Result<ListChannelsResponse, RusotoError<ListChannelsError>>;
async fn list_dataset_contents(
&self,
input: ListDatasetContentsRequest,
) -> Result<ListDatasetContentsResponse, RusotoError<ListDatasetContentsError>>;
async fn list_datasets(
&self,
input: ListDatasetsRequest,
) -> Result<ListDatasetsResponse, RusotoError<ListDatasetsError>>;
async fn list_datastores(
&self,
input: ListDatastoresRequest,
) -> Result<ListDatastoresResponse, RusotoError<ListDatastoresError>>;
async fn list_pipelines(
&self,
input: ListPipelinesRequest,
) -> Result<ListPipelinesResponse, RusotoError<ListPipelinesError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
async fn put_logging_options(
&self,
input: PutLoggingOptionsRequest,
) -> Result<(), RusotoError<PutLoggingOptionsError>>;
async fn run_pipeline_activity(
&self,
input: RunPipelineActivityRequest,
) -> Result<RunPipelineActivityResponse, RusotoError<RunPipelineActivityError>>;
async fn sample_channel_data(
&self,
input: SampleChannelDataRequest,
) -> Result<SampleChannelDataResponse, RusotoError<SampleChannelDataError>>;
async fn start_pipeline_reprocessing(
&self,
input: StartPipelineReprocessingRequest,
) -> Result<StartPipelineReprocessingResponse, RusotoError<StartPipelineReprocessingError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>>;
async fn update_channel(
&self,
input: UpdateChannelRequest,
) -> Result<(), RusotoError<UpdateChannelError>>;
async fn update_dataset(
&self,
input: UpdateDatasetRequest,
) -> Result<(), RusotoError<UpdateDatasetError>>;
async fn update_datastore(
&self,
input: UpdateDatastoreRequest,
) -> Result<(), RusotoError<UpdateDatastoreError>>;
async fn update_pipeline(
&self,
input: UpdatePipelineRequest,
) -> Result<(), RusotoError<UpdatePipelineError>>;
}
#[derive(Clone)]
pub struct IotAnalyticsClient {
client: Client,
region: region::Region,
}
impl IotAnalyticsClient {
pub fn new(region: region::Region) -> IotAnalyticsClient {
IotAnalyticsClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> IotAnalyticsClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
IotAnalyticsClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> IotAnalyticsClient {
IotAnalyticsClient { client, region }
}
}
#[async_trait]
impl IotAnalytics for IotAnalyticsClient {
#[allow(unused_mut)]
async fn batch_put_message(
&self,
input: BatchPutMessageRequest,
) -> Result<BatchPutMessageResponse, RusotoError<BatchPutMessageError>> {
let request_uri = "/messages/batch";
let mut request = SignedRequest::new("POST", "iotanalytics", &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::<BatchPutMessageResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(BatchPutMessageError::from_response(response))
}
}
#[allow(unused_mut)]
async fn cancel_pipeline_reprocessing(
&self,
input: CancelPipelineReprocessingRequest,
) -> Result<CancelPipelineReprocessingResponse, RusotoError<CancelPipelineReprocessingError>>
{
let request_uri = format!(
"/pipelines/{pipeline_name}/reprocessing/{reprocessing_id}",
pipeline_name = input.pipeline_name,
reprocessing_id = input.reprocessing_id
);
let mut request = SignedRequest::new("DELETE", "iotanalytics", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CancelPipelineReprocessingResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CancelPipelineReprocessingError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_channel(
&self,
input: CreateChannelRequest,
) -> Result<CreateChannelResponse, RusotoError<CreateChannelError>> {
let request_uri = "/channels";
let mut request = SignedRequest::new("POST", "iotanalytics", &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() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateChannelResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateChannelError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_dataset(
&self,
input: CreateDatasetRequest,
) -> Result<CreateDatasetResponse, RusotoError<CreateDatasetError>> {
let request_uri = "/datasets";
let mut request = SignedRequest::new("POST", "iotanalytics", &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() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateDatasetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateDatasetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_dataset_content(
&self,
input: CreateDatasetContentRequest,
) -> Result<CreateDatasetContentResponse, RusotoError<CreateDatasetContentError>> {
let request_uri = format!(
"/datasets/{dataset_name}/content",
dataset_name = input.dataset_name
);
let mut request = SignedRequest::new("POST", "iotanalytics", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateDatasetContentResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateDatasetContentError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_datastore(
&self,
input: CreateDatastoreRequest,
) -> Result<CreateDatastoreResponse, RusotoError<CreateDatastoreError>> {
let request_uri = "/datastores";
let mut request = SignedRequest::new("POST", "iotanalytics", &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() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateDatastoreResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateDatastoreError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_pipeline(
&self,
input: CreatePipelineRequest,
) -> Result<CreatePipelineResponse, RusotoError<CreatePipelineError>> {
let request_uri = "/pipelines";
let mut request = SignedRequest::new("POST", "iotanalytics", &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() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreatePipelineResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreatePipelineError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_channel(
&self,
input: DeleteChannelRequest,
) -> Result<(), RusotoError<DeleteChannelError>> {
let request_uri = format!(
"/channels/{channel_name}",
channel_name = input.channel_name
);
let mut request = SignedRequest::new("DELETE", "iotanalytics", &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() == 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(DeleteChannelError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_dataset(
&self,
input: DeleteDatasetRequest,
) -> Result<(), RusotoError<DeleteDatasetError>> {
let request_uri = format!(
"/datasets/{dataset_name}",
dataset_name = input.dataset_name
);
let mut request = SignedRequest::new("DELETE", "iotanalytics", &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() == 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(DeleteDatasetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_dataset_content(
&self,
input: DeleteDatasetContentRequest,
) -> Result<(), RusotoError<DeleteDatasetContentError>> {
let request_uri = format!(
"/datasets/{dataset_name}/content",
dataset_name = input.dataset_name
);
let mut request = SignedRequest::new("DELETE", "iotanalytics", &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.version_id {
params.put("versionId", x);
}
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(DeleteDatasetContentError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_datastore(
&self,
input: DeleteDatastoreRequest,
) -> Result<(), RusotoError<DeleteDatastoreError>> {
let request_uri = format!(
"/datastores/{datastore_name}",
datastore_name = input.datastore_name
);
let mut request = SignedRequest::new("DELETE", "iotanalytics", &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() == 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(DeleteDatastoreError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_pipeline(
&self,
input: DeletePipelineRequest,
) -> Result<(), RusotoError<DeletePipelineError>> {
let request_uri = format!(
"/pipelines/{pipeline_name}",
pipeline_name = input.pipeline_name
);
let mut request = SignedRequest::new("DELETE", "iotanalytics", &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() == 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(DeletePipelineError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_channel(
&self,
input: DescribeChannelRequest,
) -> Result<DescribeChannelResponse, RusotoError<DescribeChannelError>> {
let request_uri = format!(
"/channels/{channel_name}",
channel_name = input.channel_name
);
let mut request = SignedRequest::new("GET", "iotanalytics", &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.include_statistics {
params.put("includeStatistics", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeChannelResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeChannelError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_dataset(
&self,
input: DescribeDatasetRequest,
) -> Result<DescribeDatasetResponse, RusotoError<DescribeDatasetError>> {
let request_uri = format!(
"/datasets/{dataset_name}",
dataset_name = input.dataset_name
);
let mut request = SignedRequest::new("GET", "iotanalytics", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeDatasetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeDatasetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_datastore(
&self,
input: DescribeDatastoreRequest,
) -> Result<DescribeDatastoreResponse, RusotoError<DescribeDatastoreError>> {
let request_uri = format!(
"/datastores/{datastore_name}",
datastore_name = input.datastore_name
);
let mut request = SignedRequest::new("GET", "iotanalytics", &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.include_statistics {
params.put("includeStatistics", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeDatastoreResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeDatastoreError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_logging_options(
&self,
) -> Result<DescribeLoggingOptionsResponse, RusotoError<DescribeLoggingOptionsError>> {
let request_uri = "/logging";
let mut request = SignedRequest::new("GET", "iotanalytics", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeLoggingOptionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeLoggingOptionsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_pipeline(
&self,
input: DescribePipelineRequest,
) -> Result<DescribePipelineResponse, RusotoError<DescribePipelineError>> {
let request_uri = format!(
"/pipelines/{pipeline_name}",
pipeline_name = input.pipeline_name
);
let mut request = SignedRequest::new("GET", "iotanalytics", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribePipelineResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribePipelineError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_dataset_content(
&self,
input: GetDatasetContentRequest,
) -> Result<GetDatasetContentResponse, RusotoError<GetDatasetContentError>> {
let request_uri = format!(
"/datasets/{dataset_name}/content",
dataset_name = input.dataset_name
);
let mut request = SignedRequest::new("GET", "iotanalytics", &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.version_id {
params.put("versionId", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetDatasetContentResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetDatasetContentError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_channels(
&self,
input: ListChannelsRequest,
) -> Result<ListChannelsResponse, RusotoError<ListChannelsError>> {
let request_uri = "/channels";
let mut request = SignedRequest::new("GET", "iotanalytics", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListChannelsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListChannelsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_dataset_contents(
&self,
input: ListDatasetContentsRequest,
) -> Result<ListDatasetContentsResponse, RusotoError<ListDatasetContentsError>> {
let request_uri = format!(
"/datasets/{dataset_name}/contents",
dataset_name = input.dataset_name
);
let mut request = SignedRequest::new("GET", "iotanalytics", &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);
}
if let Some(ref x) = input.scheduled_before {
params.put("scheduledBefore", x);
}
if let Some(ref x) = input.scheduled_on_or_after {
params.put("scheduledOnOrAfter", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListDatasetContentsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListDatasetContentsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_datasets(
&self,
input: ListDatasetsRequest,
) -> Result<ListDatasetsResponse, RusotoError<ListDatasetsError>> {
let request_uri = "/datasets";
let mut request = SignedRequest::new("GET", "iotanalytics", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListDatasetsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListDatasetsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_datastores(
&self,
input: ListDatastoresRequest,
) -> Result<ListDatastoresResponse, RusotoError<ListDatastoresError>> {
let request_uri = "/datastores";
let mut request = SignedRequest::new("GET", "iotanalytics", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListDatastoresResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListDatastoresError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_pipelines(
&self,
input: ListPipelinesRequest,
) -> Result<ListPipelinesResponse, RusotoError<ListPipelinesError>> {
let request_uri = "/pipelines";
let mut request = SignedRequest::new("GET", "iotanalytics", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListPipelinesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListPipelinesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>> {
let request_uri = "/tags";
let mut request = SignedRequest::new("GET", "iotanalytics", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put("resourceArn", &input.resource_arn);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListTagsForResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListTagsForResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn put_logging_options(
&self,
input: PutLoggingOptionsRequest,
) -> Result<(), RusotoError<PutLoggingOptionsError>> {
let request_uri = "/logging";
let mut request = SignedRequest::new("PUT", "iotanalytics", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutLoggingOptionsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn run_pipeline_activity(
&self,
input: RunPipelineActivityRequest,
) -> Result<RunPipelineActivityResponse, RusotoError<RunPipelineActivityError>> {
let request_uri = "/pipelineactivities/run";
let mut request = SignedRequest::new("POST", "iotanalytics", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<RunPipelineActivityResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(RunPipelineActivityError::from_response(response))
}
}
#[allow(unused_mut)]
async fn sample_channel_data(
&self,
input: SampleChannelDataRequest,
) -> Result<SampleChannelDataResponse, RusotoError<SampleChannelDataError>> {
let request_uri = format!(
"/channels/{channel_name}/sample",
channel_name = input.channel_name
);
let mut request = SignedRequest::new("GET", "iotanalytics", &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.end_time {
params.put("endTime", x);
}
if let Some(ref x) = input.max_messages {
params.put("maxMessages", x);
}
if let Some(ref x) = input.start_time {
params.put("startTime", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<SampleChannelDataResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(SampleChannelDataError::from_response(response))
}
}
#[allow(unused_mut)]
async fn start_pipeline_reprocessing(
&self,
input: StartPipelineReprocessingRequest,
) -> Result<StartPipelineReprocessingResponse, RusotoError<StartPipelineReprocessingError>>
{
let request_uri = format!(
"/pipelines/{pipeline_name}/reprocessing",
pipeline_name = input.pipeline_name
);
let mut request = SignedRequest::new("POST", "iotanalytics", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<StartPipelineReprocessingResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(StartPipelineReprocessingError::from_response(response))
}
}
#[allow(unused_mut)]
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>> {
let request_uri = "/tags";
let mut request = SignedRequest::new("POST", "iotanalytics", &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 params = Params::new();
params.put("resourceArn", &input.resource_arn);
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 = proto::json::ResponsePayload::new(&response)
.deserialize::<TagResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(TagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>> {
let request_uri = "/tags";
let mut request = SignedRequest::new("DELETE", "iotanalytics", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put("resourceArn", &input.resource_arn);
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 = proto::json::ResponsePayload::new(&response)
.deserialize::<UntagResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UntagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_channel(
&self,
input: UpdateChannelRequest,
) -> Result<(), RusotoError<UpdateChannelError>> {
let request_uri = format!(
"/channels/{channel_name}",
channel_name = input.channel_name
);
let mut request = SignedRequest::new("PUT", "iotanalytics", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateChannelError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_dataset(
&self,
input: UpdateDatasetRequest,
) -> Result<(), RusotoError<UpdateDatasetError>> {
let request_uri = format!(
"/datasets/{dataset_name}",
dataset_name = input.dataset_name
);
let mut request = SignedRequest::new("PUT", "iotanalytics", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateDatasetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_datastore(
&self,
input: UpdateDatastoreRequest,
) -> Result<(), RusotoError<UpdateDatastoreError>> {
let request_uri = format!(
"/datastores/{datastore_name}",
datastore_name = input.datastore_name
);
let mut request = SignedRequest::new("PUT", "iotanalytics", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateDatastoreError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_pipeline(
&self,
input: UpdatePipelineRequest,
) -> Result<(), RusotoError<UpdatePipelineError>> {
let request_uri = format!(
"/pipelines/{pipeline_name}",
pipeline_name = input.pipeline_name
);
let mut request = SignedRequest::new("PUT", "iotanalytics", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdatePipelineError::from_response(response))
}
}
}