use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::proto;
use rusoto_core::request::HttpResponse;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
impl ConfigServiceClient {
fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
let mut request = SignedRequest::new(http_method, "config", &self.region, request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request
}
async fn sign_and_dispatch<E>(
&self,
request: SignedRequest,
from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
) -> Result<HttpResponse, RusotoError<E>> {
let mut response = self.client.sign_and_dispatch(request).await?;
if !response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
return Err(from_response(response));
}
Ok(response)
}
}
use serde_json;
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AccountAggregationSource {
#[serde(rename = "AccountIds")]
pub account_ids: Vec<String>,
#[serde(rename = "AllAwsRegions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub all_aws_regions: Option<bool>,
#[serde(rename = "AwsRegions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aws_regions: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AggregateComplianceByConfigRule {
#[serde(rename = "AccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_id: Option<String>,
#[serde(rename = "AwsRegion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aws_region: Option<String>,
#[serde(rename = "Compliance")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compliance: Option<Compliance>,
#[serde(rename = "ConfigRuleName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_rule_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AggregateComplianceCount {
#[serde(rename = "ComplianceSummary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compliance_summary: Option<ComplianceSummary>,
#[serde(rename = "GroupName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AggregateEvaluationResult {
#[serde(rename = "AccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_id: Option<String>,
#[serde(rename = "Annotation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub annotation: Option<String>,
#[serde(rename = "AwsRegion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aws_region: Option<String>,
#[serde(rename = "ComplianceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compliance_type: Option<String>,
#[serde(rename = "ConfigRuleInvokedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_rule_invoked_time: Option<f64>,
#[serde(rename = "EvaluationResultIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub evaluation_result_identifier: Option<EvaluationResultIdentifier>,
#[serde(rename = "ResultRecordedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub result_recorded_time: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AggregateResourceIdentifier {
#[serde(rename = "ResourceId")]
pub resource_id: String,
#[serde(rename = "ResourceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_name: Option<String>,
#[serde(rename = "ResourceType")]
pub resource_type: String,
#[serde(rename = "SourceAccountId")]
pub source_account_id: String,
#[serde(rename = "SourceRegion")]
pub source_region: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AggregatedSourceStatus {
#[serde(rename = "AwsRegion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aws_region: Option<String>,
#[serde(rename = "LastErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_error_code: Option<String>,
#[serde(rename = "LastErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_error_message: Option<String>,
#[serde(rename = "LastUpdateStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_update_status: Option<String>,
#[serde(rename = "LastUpdateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_update_time: Option<f64>,
#[serde(rename = "SourceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_id: Option<String>,
#[serde(rename = "SourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AggregationAuthorization {
#[serde(rename = "AggregationAuthorizationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aggregation_authorization_arn: Option<String>,
#[serde(rename = "AuthorizedAccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorized_account_id: Option<String>,
#[serde(rename = "AuthorizedAwsRegion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorized_aws_region: Option<String>,
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BaseConfigurationItem {
#[serde(rename = "accountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_id: Option<String>,
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "availabilityZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub availability_zone: Option<String>,
#[serde(rename = "awsRegion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aws_region: Option<String>,
#[serde(rename = "configuration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration: Option<String>,
#[serde(rename = "configurationItemCaptureTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_item_capture_time: Option<f64>,
#[serde(rename = "configurationItemStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_item_status: Option<String>,
#[serde(rename = "configurationStateId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_state_id: Option<String>,
#[serde(rename = "resourceCreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_creation_time: Option<f64>,
#[serde(rename = "resourceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_id: Option<String>,
#[serde(rename = "resourceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_name: Option<String>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "supplementaryConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub supplementary_configuration: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchGetAggregateResourceConfigRequest {
#[serde(rename = "ConfigurationAggregatorName")]
pub configuration_aggregator_name: String,
#[serde(rename = "ResourceIdentifiers")]
pub resource_identifiers: Vec<AggregateResourceIdentifier>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchGetAggregateResourceConfigResponse {
#[serde(rename = "BaseConfigurationItems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub base_configuration_items: Option<Vec<BaseConfigurationItem>>,
#[serde(rename = "UnprocessedResourceIdentifiers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unprocessed_resource_identifiers: Option<Vec<AggregateResourceIdentifier>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchGetResourceConfigRequest {
#[serde(rename = "resourceKeys")]
pub resource_keys: Vec<ResourceKey>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchGetResourceConfigResponse {
#[serde(rename = "baseConfigurationItems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub base_configuration_items: Option<Vec<BaseConfigurationItem>>,
#[serde(rename = "unprocessedResourceKeys")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unprocessed_resource_keys: Option<Vec<ResourceKey>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Compliance {
#[serde(rename = "ComplianceContributorCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compliance_contributor_count: Option<ComplianceContributorCount>,
#[serde(rename = "ComplianceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compliance_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ComplianceByConfigRule {
#[serde(rename = "Compliance")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compliance: Option<Compliance>,
#[serde(rename = "ConfigRuleName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_rule_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ComplianceByResource {
#[serde(rename = "Compliance")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compliance: Option<Compliance>,
#[serde(rename = "ResourceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_id: Option<String>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ComplianceContributorCount {
#[serde(rename = "CapExceeded")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cap_exceeded: Option<bool>,
#[serde(rename = "CappedCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub capped_count: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ComplianceSummary {
#[serde(rename = "ComplianceSummaryTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compliance_summary_timestamp: Option<f64>,
#[serde(rename = "CompliantResourceCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compliant_resource_count: Option<ComplianceContributorCount>,
#[serde(rename = "NonCompliantResourceCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub non_compliant_resource_count: Option<ComplianceContributorCount>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ComplianceSummaryByResourceType {
#[serde(rename = "ComplianceSummary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compliance_summary: Option<ComplianceSummary>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConfigExportDeliveryInfo {
#[serde(rename = "lastAttemptTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_attempt_time: Option<f64>,
#[serde(rename = "lastErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_error_code: Option<String>,
#[serde(rename = "lastErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_error_message: Option<String>,
#[serde(rename = "lastStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_status: Option<String>,
#[serde(rename = "lastSuccessfulTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_successful_time: Option<f64>,
#[serde(rename = "nextDeliveryTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_delivery_time: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ConfigRule {
#[serde(rename = "ConfigRuleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_rule_arn: Option<String>,
#[serde(rename = "ConfigRuleId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_rule_id: Option<String>,
#[serde(rename = "ConfigRuleName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_rule_name: Option<String>,
#[serde(rename = "ConfigRuleState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_rule_state: Option<String>,
#[serde(rename = "CreatedBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_by: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "InputParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_parameters: Option<String>,
#[serde(rename = "MaximumExecutionFrequency")]
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum_execution_frequency: Option<String>,
#[serde(rename = "Scope")]
#[serde(skip_serializing_if = "Option::is_none")]
pub scope: Option<Scope>,
#[serde(rename = "Source")]
pub source: Source,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ConfigRuleComplianceFilters {
#[serde(rename = "AccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_id: Option<String>,
#[serde(rename = "AwsRegion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aws_region: Option<String>,
#[serde(rename = "ComplianceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compliance_type: Option<String>,
#[serde(rename = "ConfigRuleName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_rule_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ConfigRuleComplianceSummaryFilters {
#[serde(rename = "AccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_id: Option<String>,
#[serde(rename = "AwsRegion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aws_region: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConfigRuleEvaluationStatus {
#[serde(rename = "ConfigRuleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_rule_arn: Option<String>,
#[serde(rename = "ConfigRuleId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_rule_id: Option<String>,
#[serde(rename = "ConfigRuleName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_rule_name: Option<String>,
#[serde(rename = "FirstActivatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub first_activated_time: Option<f64>,
#[serde(rename = "FirstEvaluationStarted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub first_evaluation_started: Option<bool>,
#[serde(rename = "LastDeactivatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_deactivated_time: Option<f64>,
#[serde(rename = "LastErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_error_code: Option<String>,
#[serde(rename = "LastErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_error_message: Option<String>,
#[serde(rename = "LastFailedEvaluationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_failed_evaluation_time: Option<f64>,
#[serde(rename = "LastFailedInvocationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_failed_invocation_time: Option<f64>,
#[serde(rename = "LastSuccessfulEvaluationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_successful_evaluation_time: Option<f64>,
#[serde(rename = "LastSuccessfulInvocationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_successful_invocation_time: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ConfigSnapshotDeliveryProperties {
#[serde(rename = "deliveryFrequency")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delivery_frequency: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConfigStreamDeliveryInfo {
#[serde(rename = "lastErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_error_code: Option<String>,
#[serde(rename = "lastErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_error_message: Option<String>,
#[serde(rename = "lastStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_status: Option<String>,
#[serde(rename = "lastStatusChangeTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_status_change_time: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConfigurationAggregator {
#[serde(rename = "AccountAggregationSources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_aggregation_sources: Option<Vec<AccountAggregationSource>>,
#[serde(rename = "ConfigurationAggregatorArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_aggregator_arn: Option<String>,
#[serde(rename = "ConfigurationAggregatorName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_aggregator_name: Option<String>,
#[serde(rename = "CreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_time: Option<f64>,
#[serde(rename = "LastUpdatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_time: Option<f64>,
#[serde(rename = "OrganizationAggregationSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_aggregation_source: Option<OrganizationAggregationSource>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConfigurationItem {
#[serde(rename = "accountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_id: Option<String>,
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "availabilityZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub availability_zone: Option<String>,
#[serde(rename = "awsRegion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aws_region: Option<String>,
#[serde(rename = "configuration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration: Option<String>,
#[serde(rename = "configurationItemCaptureTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_item_capture_time: Option<f64>,
#[serde(rename = "configurationItemMD5Hash")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_item_md5_hash: Option<String>,
#[serde(rename = "configurationItemStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_item_status: Option<String>,
#[serde(rename = "configurationStateId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_state_id: Option<String>,
#[serde(rename = "relatedEvents")]
#[serde(skip_serializing_if = "Option::is_none")]
pub related_events: Option<Vec<String>>,
#[serde(rename = "relationships")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relationships: Option<Vec<Relationship>>,
#[serde(rename = "resourceCreationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_creation_time: Option<f64>,
#[serde(rename = "resourceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_id: Option<String>,
#[serde(rename = "resourceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_name: Option<String>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "supplementaryConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub supplementary_configuration: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ConfigurationRecorder {
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "recordingGroup")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recording_group: Option<RecordingGroup>,
#[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 ConfigurationRecorderStatus {
#[serde(rename = "lastErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_error_code: Option<String>,
#[serde(rename = "lastErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_error_message: Option<String>,
#[serde(rename = "lastStartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_start_time: Option<f64>,
#[serde(rename = "lastStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_status: Option<String>,
#[serde(rename = "lastStatusChangeTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_status_change_time: Option<f64>,
#[serde(rename = "lastStopTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_stop_time: Option<f64>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "recording")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recording: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ConformancePackComplianceFilters {
#[serde(rename = "ComplianceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compliance_type: Option<String>,
#[serde(rename = "ConfigRuleNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_rule_names: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConformancePackComplianceSummary {
#[serde(rename = "ConformancePackComplianceStatus")]
pub conformance_pack_compliance_status: String,
#[serde(rename = "ConformancePackName")]
pub conformance_pack_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConformancePackDetail {
#[serde(rename = "ConformancePackArn")]
pub conformance_pack_arn: String,
#[serde(rename = "ConformancePackId")]
pub conformance_pack_id: String,
#[serde(rename = "ConformancePackInputParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conformance_pack_input_parameters: Option<Vec<ConformancePackInputParameter>>,
#[serde(rename = "ConformancePackName")]
pub conformance_pack_name: String,
#[serde(rename = "CreatedBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_by: Option<String>,
#[serde(rename = "DeliveryS3Bucket")]
pub delivery_s3_bucket: String,
#[serde(rename = "DeliveryS3KeyPrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delivery_s3_key_prefix: Option<String>,
#[serde(rename = "LastUpdateRequestedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_update_requested_time: Option<f64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ConformancePackEvaluationFilters {
#[serde(rename = "ComplianceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compliance_type: Option<String>,
#[serde(rename = "ConfigRuleNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_rule_names: Option<Vec<String>>,
#[serde(rename = "ResourceIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_ids: Option<Vec<String>>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConformancePackEvaluationResult {
#[serde(rename = "Annotation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub annotation: Option<String>,
#[serde(rename = "ComplianceType")]
pub compliance_type: String,
#[serde(rename = "ConfigRuleInvokedTime")]
pub config_rule_invoked_time: f64,
#[serde(rename = "EvaluationResultIdentifier")]
pub evaluation_result_identifier: EvaluationResultIdentifier,
#[serde(rename = "ResultRecordedTime")]
pub result_recorded_time: f64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ConformancePackInputParameter {
#[serde(rename = "ParameterName")]
pub parameter_name: String,
#[serde(rename = "ParameterValue")]
pub parameter_value: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConformancePackRuleCompliance {
#[serde(rename = "ComplianceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compliance_type: Option<String>,
#[serde(rename = "ConfigRuleName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_rule_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConformancePackStatusDetail {
#[serde(rename = "ConformancePackArn")]
pub conformance_pack_arn: String,
#[serde(rename = "ConformancePackId")]
pub conformance_pack_id: String,
#[serde(rename = "ConformancePackName")]
pub conformance_pack_name: String,
#[serde(rename = "ConformancePackState")]
pub conformance_pack_state: String,
#[serde(rename = "ConformancePackStatusReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conformance_pack_status_reason: Option<String>,
#[serde(rename = "LastUpdateCompletedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_update_completed_time: Option<f64>,
#[serde(rename = "LastUpdateRequestedTime")]
pub last_update_requested_time: f64,
#[serde(rename = "StackArn")]
pub stack_arn: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteAggregationAuthorizationRequest {
#[serde(rename = "AuthorizedAccountId")]
pub authorized_account_id: String,
#[serde(rename = "AuthorizedAwsRegion")]
pub authorized_aws_region: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteConfigRuleRequest {
#[serde(rename = "ConfigRuleName")]
pub config_rule_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteConfigurationAggregatorRequest {
#[serde(rename = "ConfigurationAggregatorName")]
pub configuration_aggregator_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteConfigurationRecorderRequest {
#[serde(rename = "ConfigurationRecorderName")]
pub configuration_recorder_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteConformancePackRequest {
#[serde(rename = "ConformancePackName")]
pub conformance_pack_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDeliveryChannelRequest {
#[serde(rename = "DeliveryChannelName")]
pub delivery_channel_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteEvaluationResultsRequest {
#[serde(rename = "ConfigRuleName")]
pub config_rule_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteEvaluationResultsResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteOrganizationConfigRuleRequest {
#[serde(rename = "OrganizationConfigRuleName")]
pub organization_config_rule_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteOrganizationConformancePackRequest {
#[serde(rename = "OrganizationConformancePackName")]
pub organization_conformance_pack_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeletePendingAggregationRequestRequest {
#[serde(rename = "RequesterAccountId")]
pub requester_account_id: String,
#[serde(rename = "RequesterAwsRegion")]
pub requester_aws_region: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteRemediationConfigurationRequest {
#[serde(rename = "ConfigRuleName")]
pub config_rule_name: String,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteRemediationConfigurationResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteRemediationExceptionsRequest {
#[serde(rename = "ConfigRuleName")]
pub config_rule_name: String,
#[serde(rename = "ResourceKeys")]
pub resource_keys: Vec<RemediationExceptionResourceKey>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteRemediationExceptionsResponse {
#[serde(rename = "FailedBatches")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed_batches: Option<Vec<FailedDeleteRemediationExceptionsBatch>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteResourceConfigRequest {
#[serde(rename = "ResourceId")]
pub resource_id: String,
#[serde(rename = "ResourceType")]
pub resource_type: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteRetentionConfigurationRequest {
#[serde(rename = "RetentionConfigurationName")]
pub retention_configuration_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeliverConfigSnapshotRequest {
#[serde(rename = "deliveryChannelName")]
pub delivery_channel_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeliverConfigSnapshotResponse {
#[serde(rename = "configSnapshotId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_snapshot_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DeliveryChannel {
#[serde(rename = "configSnapshotDeliveryProperties")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_snapshot_delivery_properties: Option<ConfigSnapshotDeliveryProperties>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "s3BucketName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s_3_bucket_name: Option<String>,
#[serde(rename = "s3KeyPrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s_3_key_prefix: Option<String>,
#[serde(rename = "snsTopicARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sns_topic_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeliveryChannelStatus {
#[serde(rename = "configHistoryDeliveryInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_history_delivery_info: Option<ConfigExportDeliveryInfo>,
#[serde(rename = "configSnapshotDeliveryInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_snapshot_delivery_info: Option<ConfigExportDeliveryInfo>,
#[serde(rename = "configStreamDeliveryInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_stream_delivery_info: Option<ConfigStreamDeliveryInfo>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeAggregateComplianceByConfigRulesRequest {
#[serde(rename = "ConfigurationAggregatorName")]
pub configuration_aggregator_name: String,
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<ConfigRuleComplianceFilters>,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeAggregateComplianceByConfigRulesResponse {
#[serde(rename = "AggregateComplianceByConfigRules")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aggregate_compliance_by_config_rules: Option<Vec<AggregateComplianceByConfigRule>>,
#[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 DescribeAggregationAuthorizationsRequest {
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeAggregationAuthorizationsResponse {
#[serde(rename = "AggregationAuthorizations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aggregation_authorizations: Option<Vec<AggregationAuthorization>>,
#[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 DescribeComplianceByConfigRuleRequest {
#[serde(rename = "ComplianceTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compliance_types: Option<Vec<String>>,
#[serde(rename = "ConfigRuleNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_rule_names: Option<Vec<String>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeComplianceByConfigRuleResponse {
#[serde(rename = "ComplianceByConfigRules")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compliance_by_config_rules: Option<Vec<ComplianceByConfigRule>>,
#[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 DescribeComplianceByResourceRequest {
#[serde(rename = "ComplianceTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compliance_types: Option<Vec<String>>,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ResourceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_id: Option<String>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeComplianceByResourceResponse {
#[serde(rename = "ComplianceByResources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compliance_by_resources: Option<Vec<ComplianceByResource>>,
#[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 DescribeConfigRuleEvaluationStatusRequest {
#[serde(rename = "ConfigRuleNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_rule_names: Option<Vec<String>>,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeConfigRuleEvaluationStatusResponse {
#[serde(rename = "ConfigRulesEvaluationStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_rules_evaluation_status: Option<Vec<ConfigRuleEvaluationStatus>>,
#[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 DescribeConfigRulesRequest {
#[serde(rename = "ConfigRuleNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_rule_names: Option<Vec<String>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeConfigRulesResponse {
#[serde(rename = "ConfigRules")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_rules: Option<Vec<ConfigRule>>,
#[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 DescribeConfigurationAggregatorSourcesStatusRequest {
#[serde(rename = "ConfigurationAggregatorName")]
pub configuration_aggregator_name: String,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "UpdateStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub update_status: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeConfigurationAggregatorSourcesStatusResponse {
#[serde(rename = "AggregatedSourceStatusList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aggregated_source_status_list: Option<Vec<AggregatedSourceStatus>>,
#[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 DescribeConfigurationAggregatorsRequest {
#[serde(rename = "ConfigurationAggregatorNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_aggregator_names: Option<Vec<String>>,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeConfigurationAggregatorsResponse {
#[serde(rename = "ConfigurationAggregators")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_aggregators: Option<Vec<ConfigurationAggregator>>,
#[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 DescribeConfigurationRecorderStatusRequest {
#[serde(rename = "ConfigurationRecorderNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_recorder_names: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeConfigurationRecorderStatusResponse {
#[serde(rename = "ConfigurationRecordersStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_recorders_status: Option<Vec<ConfigurationRecorderStatus>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeConfigurationRecordersRequest {
#[serde(rename = "ConfigurationRecorderNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_recorder_names: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeConfigurationRecordersResponse {
#[serde(rename = "ConfigurationRecorders")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_recorders: Option<Vec<ConfigurationRecorder>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeConformancePackComplianceRequest {
#[serde(rename = "ConformancePackName")]
pub conformance_pack_name: String,
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<ConformancePackComplianceFilters>,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeConformancePackComplianceResponse {
#[serde(rename = "ConformancePackName")]
pub conformance_pack_name: String,
#[serde(rename = "ConformancePackRuleComplianceList")]
pub conformance_pack_rule_compliance_list: Vec<ConformancePackRuleCompliance>,
#[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 DescribeConformancePackStatusRequest {
#[serde(rename = "ConformancePackNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conformance_pack_names: Option<Vec<String>>,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeConformancePackStatusResponse {
#[serde(rename = "ConformancePackStatusDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conformance_pack_status_details: Option<Vec<ConformancePackStatusDetail>>,
#[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 DescribeConformancePacksRequest {
#[serde(rename = "ConformancePackNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conformance_pack_names: Option<Vec<String>>,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeConformancePacksResponse {
#[serde(rename = "ConformancePackDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conformance_pack_details: Option<Vec<ConformancePackDetail>>,
#[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 DescribeDeliveryChannelStatusRequest {
#[serde(rename = "DeliveryChannelNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delivery_channel_names: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeDeliveryChannelStatusResponse {
#[serde(rename = "DeliveryChannelsStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delivery_channels_status: Option<Vec<DeliveryChannelStatus>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeDeliveryChannelsRequest {
#[serde(rename = "DeliveryChannelNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delivery_channel_names: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeDeliveryChannelsResponse {
#[serde(rename = "DeliveryChannels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delivery_channels: Option<Vec<DeliveryChannel>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeOrganizationConfigRuleStatusesRequest {
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "OrganizationConfigRuleNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_config_rule_names: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeOrganizationConfigRuleStatusesResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "OrganizationConfigRuleStatuses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_config_rule_statuses: Option<Vec<OrganizationConfigRuleStatus>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeOrganizationConfigRulesRequest {
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "OrganizationConfigRuleNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_config_rule_names: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeOrganizationConfigRulesResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "OrganizationConfigRules")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_config_rules: Option<Vec<OrganizationConfigRule>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeOrganizationConformancePackStatusesRequest {
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "OrganizationConformancePackNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_conformance_pack_names: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeOrganizationConformancePackStatusesResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "OrganizationConformancePackStatuses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_conformance_pack_statuses: Option<Vec<OrganizationConformancePackStatus>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeOrganizationConformancePacksRequest {
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "OrganizationConformancePackNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_conformance_pack_names: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeOrganizationConformancePacksResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "OrganizationConformancePacks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_conformance_packs: Option<Vec<OrganizationConformancePack>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribePendingAggregationRequestsRequest {
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribePendingAggregationRequestsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "PendingAggregationRequests")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pending_aggregation_requests: Option<Vec<PendingAggregationRequest>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeRemediationConfigurationsRequest {
#[serde(rename = "ConfigRuleNames")]
pub config_rule_names: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeRemediationConfigurationsResponse {
#[serde(rename = "RemediationConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remediation_configurations: Option<Vec<RemediationConfiguration>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeRemediationExceptionsRequest {
#[serde(rename = "ConfigRuleName")]
pub config_rule_name: String,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ResourceKeys")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_keys: Option<Vec<RemediationExceptionResourceKey>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeRemediationExceptionsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "RemediationExceptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remediation_exceptions: Option<Vec<RemediationException>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeRemediationExecutionStatusRequest {
#[serde(rename = "ConfigRuleName")]
pub config_rule_name: String,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ResourceKeys")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_keys: Option<Vec<ResourceKey>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeRemediationExecutionStatusResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "RemediationExecutionStatuses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remediation_execution_statuses: Option<Vec<RemediationExecutionStatus>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeRetentionConfigurationsRequest {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "RetentionConfigurationNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retention_configuration_names: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeRetentionConfigurationsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "RetentionConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retention_configurations: Option<Vec<RetentionConfiguration>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Evaluation {
#[serde(rename = "Annotation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub annotation: Option<String>,
#[serde(rename = "ComplianceResourceId")]
pub compliance_resource_id: String,
#[serde(rename = "ComplianceResourceType")]
pub compliance_resource_type: String,
#[serde(rename = "ComplianceType")]
pub compliance_type: String,
#[serde(rename = "OrderingTimestamp")]
pub ordering_timestamp: f64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EvaluationResult {
#[serde(rename = "Annotation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub annotation: Option<String>,
#[serde(rename = "ComplianceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compliance_type: Option<String>,
#[serde(rename = "ConfigRuleInvokedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_rule_invoked_time: Option<f64>,
#[serde(rename = "EvaluationResultIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub evaluation_result_identifier: Option<EvaluationResultIdentifier>,
#[serde(rename = "ResultRecordedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub result_recorded_time: Option<f64>,
#[serde(rename = "ResultToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub result_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EvaluationResultIdentifier {
#[serde(rename = "EvaluationResultQualifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub evaluation_result_qualifier: Option<EvaluationResultQualifier>,
#[serde(rename = "OrderingTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ordering_timestamp: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EvaluationResultQualifier {
#[serde(rename = "ConfigRuleName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_rule_name: Option<String>,
#[serde(rename = "ResourceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_id: Option<String>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ExecutionControls {
#[serde(rename = "SsmControls")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ssm_controls: Option<SsmControls>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FailedDeleteRemediationExceptionsBatch {
#[serde(rename = "FailedItems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed_items: Option<Vec<RemediationExceptionResourceKey>>,
#[serde(rename = "FailureMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_message: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FailedRemediationBatch {
#[serde(rename = "FailedItems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed_items: Option<Vec<RemediationConfiguration>>,
#[serde(rename = "FailureMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_message: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FailedRemediationExceptionBatch {
#[serde(rename = "FailedItems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed_items: Option<Vec<RemediationException>>,
#[serde(rename = "FailureMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_message: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FieldInfo {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetAggregateComplianceDetailsByConfigRuleRequest {
#[serde(rename = "AccountId")]
pub account_id: String,
#[serde(rename = "AwsRegion")]
pub aws_region: String,
#[serde(rename = "ComplianceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compliance_type: Option<String>,
#[serde(rename = "ConfigRuleName")]
pub config_rule_name: String,
#[serde(rename = "ConfigurationAggregatorName")]
pub configuration_aggregator_name: String,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetAggregateComplianceDetailsByConfigRuleResponse {
#[serde(rename = "AggregateEvaluationResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aggregate_evaluation_results: Option<Vec<AggregateEvaluationResult>>,
#[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 GetAggregateConfigRuleComplianceSummaryRequest {
#[serde(rename = "ConfigurationAggregatorName")]
pub configuration_aggregator_name: String,
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<ConfigRuleComplianceSummaryFilters>,
#[serde(rename = "GroupByKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_by_key: Option<String>,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetAggregateConfigRuleComplianceSummaryResponse {
#[serde(rename = "AggregateComplianceCounts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aggregate_compliance_counts: Option<Vec<AggregateComplianceCount>>,
#[serde(rename = "GroupByKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_by_key: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetAggregateDiscoveredResourceCountsRequest {
#[serde(rename = "ConfigurationAggregatorName")]
pub configuration_aggregator_name: String,
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<ResourceCountFilters>,
#[serde(rename = "GroupByKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_by_key: Option<String>,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetAggregateDiscoveredResourceCountsResponse {
#[serde(rename = "GroupByKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_by_key: Option<String>,
#[serde(rename = "GroupedResourceCounts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub grouped_resource_counts: Option<Vec<GroupedResourceCount>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "TotalDiscoveredResources")]
pub total_discovered_resources: i64,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetAggregateResourceConfigRequest {
#[serde(rename = "ConfigurationAggregatorName")]
pub configuration_aggregator_name: String,
#[serde(rename = "ResourceIdentifier")]
pub resource_identifier: AggregateResourceIdentifier,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetAggregateResourceConfigResponse {
#[serde(rename = "ConfigurationItem")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_item: Option<ConfigurationItem>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetComplianceDetailsByConfigRuleRequest {
#[serde(rename = "ComplianceTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compliance_types: Option<Vec<String>>,
#[serde(rename = "ConfigRuleName")]
pub config_rule_name: String,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetComplianceDetailsByConfigRuleResponse {
#[serde(rename = "EvaluationResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub evaluation_results: Option<Vec<EvaluationResult>>,
#[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 GetComplianceDetailsByResourceRequest {
#[serde(rename = "ComplianceTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compliance_types: Option<Vec<String>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ResourceId")]
pub resource_id: String,
#[serde(rename = "ResourceType")]
pub resource_type: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetComplianceDetailsByResourceResponse {
#[serde(rename = "EvaluationResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub evaluation_results: Option<Vec<EvaluationResult>>,
#[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 GetComplianceSummaryByConfigRuleResponse {
#[serde(rename = "ComplianceSummary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compliance_summary: Option<ComplianceSummary>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetComplianceSummaryByResourceTypeRequest {
#[serde(rename = "ResourceTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_types: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetComplianceSummaryByResourceTypeResponse {
#[serde(rename = "ComplianceSummariesByResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compliance_summaries_by_resource_type: Option<Vec<ComplianceSummaryByResourceType>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetConformancePackComplianceDetailsRequest {
#[serde(rename = "ConformancePackName")]
pub conformance_pack_name: String,
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<ConformancePackEvaluationFilters>,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetConformancePackComplianceDetailsResponse {
#[serde(rename = "ConformancePackName")]
pub conformance_pack_name: String,
#[serde(rename = "ConformancePackRuleEvaluationResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conformance_pack_rule_evaluation_results: Option<Vec<ConformancePackEvaluationResult>>,
#[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 GetConformancePackComplianceSummaryRequest {
#[serde(rename = "ConformancePackNames")]
pub conformance_pack_names: Vec<String>,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetConformancePackComplianceSummaryResponse {
#[serde(rename = "ConformancePackComplianceSummaryList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conformance_pack_compliance_summary_list: Option<Vec<ConformancePackComplianceSummary>>,
#[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 GetDiscoveredResourceCountsRequest {
#[serde(rename = "limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "resourceTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_types: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDiscoveredResourceCountsResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "resourceCounts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_counts: Option<Vec<ResourceCount>>,
#[serde(rename = "totalDiscoveredResources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub total_discovered_resources: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetOrganizationConfigRuleDetailedStatusRequest {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<StatusDetailFilters>,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "OrganizationConfigRuleName")]
pub organization_config_rule_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetOrganizationConfigRuleDetailedStatusResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "OrganizationConfigRuleDetailedStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_config_rule_detailed_status: Option<Vec<MemberAccountStatus>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetOrganizationConformancePackDetailedStatusRequest {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<OrganizationResourceDetailedStatusFilters>,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "OrganizationConformancePackName")]
pub organization_conformance_pack_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetOrganizationConformancePackDetailedStatusResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "OrganizationConformancePackDetailedStatuses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_conformance_pack_detailed_statuses:
Option<Vec<OrganizationConformancePackDetailedStatus>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetResourceConfigHistoryRequest {
#[serde(rename = "chronologicalOrder")]
#[serde(skip_serializing_if = "Option::is_none")]
pub chronological_order: Option<String>,
#[serde(rename = "earlierTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub earlier_time: Option<f64>,
#[serde(rename = "laterTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub later_time: Option<f64>,
#[serde(rename = "limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "resourceId")]
pub resource_id: String,
#[serde(rename = "resourceType")]
pub resource_type: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetResourceConfigHistoryResponse {
#[serde(rename = "configurationItems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_items: Option<Vec<ConfigurationItem>>,
#[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 GroupedResourceCount {
#[serde(rename = "GroupName")]
pub group_name: String,
#[serde(rename = "ResourceCount")]
pub resource_count: i64,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListAggregateDiscoveredResourcesRequest {
#[serde(rename = "ConfigurationAggregatorName")]
pub configuration_aggregator_name: String,
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<ResourceFilters>,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ResourceType")]
pub resource_type: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListAggregateDiscoveredResourcesResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ResourceIdentifiers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_identifiers: Option<Vec<AggregateResourceIdentifier>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDiscoveredResourcesRequest {
#[serde(rename = "includeDeletedResources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub include_deleted_resources: Option<bool>,
#[serde(rename = "limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "resourceIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_ids: Option<Vec<String>>,
#[serde(rename = "resourceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_name: Option<String>,
#[serde(rename = "resourceType")]
pub resource_type: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDiscoveredResourcesResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "resourceIdentifiers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_identifiers: Option<Vec<ResourceIdentifier>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceRequest {
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MemberAccountStatus {
#[serde(rename = "AccountId")]
pub account_id: String,
#[serde(rename = "ConfigRuleName")]
pub config_rule_name: String,
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "LastUpdateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_update_time: Option<f64>,
#[serde(rename = "MemberAccountRuleStatus")]
pub member_account_rule_status: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct OrganizationAggregationSource {
#[serde(rename = "AllAwsRegions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub all_aws_regions: Option<bool>,
#[serde(rename = "AwsRegions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aws_regions: Option<Vec<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 OrganizationConfigRule {
#[serde(rename = "ExcludedAccounts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub excluded_accounts: Option<Vec<String>>,
#[serde(rename = "LastUpdateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_update_time: Option<f64>,
#[serde(rename = "OrganizationConfigRuleArn")]
pub organization_config_rule_arn: String,
#[serde(rename = "OrganizationConfigRuleName")]
pub organization_config_rule_name: String,
#[serde(rename = "OrganizationCustomRuleMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_custom_rule_metadata: Option<OrganizationCustomRuleMetadata>,
#[serde(rename = "OrganizationManagedRuleMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_managed_rule_metadata: Option<OrganizationManagedRuleMetadata>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct OrganizationConfigRuleStatus {
#[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 = "LastUpdateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_update_time: Option<f64>,
#[serde(rename = "OrganizationConfigRuleName")]
pub organization_config_rule_name: String,
#[serde(rename = "OrganizationRuleStatus")]
pub organization_rule_status: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct OrganizationConformancePack {
#[serde(rename = "ConformancePackInputParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conformance_pack_input_parameters: Option<Vec<ConformancePackInputParameter>>,
#[serde(rename = "DeliveryS3Bucket")]
pub delivery_s3_bucket: String,
#[serde(rename = "DeliveryS3KeyPrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delivery_s3_key_prefix: Option<String>,
#[serde(rename = "ExcludedAccounts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub excluded_accounts: Option<Vec<String>>,
#[serde(rename = "LastUpdateTime")]
pub last_update_time: f64,
#[serde(rename = "OrganizationConformancePackArn")]
pub organization_conformance_pack_arn: String,
#[serde(rename = "OrganizationConformancePackName")]
pub organization_conformance_pack_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct OrganizationConformancePackDetailedStatus {
#[serde(rename = "AccountId")]
pub account_id: String,
#[serde(rename = "ConformancePackName")]
pub conformance_pack_name: String,
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "LastUpdateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_update_time: Option<f64>,
#[serde(rename = "Status")]
pub status: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct OrganizationConformancePackStatus {
#[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 = "LastUpdateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_update_time: Option<f64>,
#[serde(rename = "OrganizationConformancePackName")]
pub organization_conformance_pack_name: String,
#[serde(rename = "Status")]
pub status: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct OrganizationCustomRuleMetadata {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "InputParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_parameters: Option<String>,
#[serde(rename = "LambdaFunctionArn")]
pub lambda_function_arn: String,
#[serde(rename = "MaximumExecutionFrequency")]
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum_execution_frequency: Option<String>,
#[serde(rename = "OrganizationConfigRuleTriggerTypes")]
pub organization_config_rule_trigger_types: Vec<String>,
#[serde(rename = "ResourceIdScope")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_id_scope: Option<String>,
#[serde(rename = "ResourceTypesScope")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_types_scope: Option<Vec<String>>,
#[serde(rename = "TagKeyScope")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tag_key_scope: Option<String>,
#[serde(rename = "TagValueScope")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tag_value_scope: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct OrganizationManagedRuleMetadata {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "InputParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub input_parameters: Option<String>,
#[serde(rename = "MaximumExecutionFrequency")]
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum_execution_frequency: Option<String>,
#[serde(rename = "ResourceIdScope")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_id_scope: Option<String>,
#[serde(rename = "ResourceTypesScope")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_types_scope: Option<Vec<String>>,
#[serde(rename = "RuleIdentifier")]
pub rule_identifier: String,
#[serde(rename = "TagKeyScope")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tag_key_scope: Option<String>,
#[serde(rename = "TagValueScope")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tag_value_scope: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct OrganizationResourceDetailedStatusFilters {
#[serde(rename = "AccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_id: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PendingAggregationRequest {
#[serde(rename = "RequesterAccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requester_account_id: Option<String>,
#[serde(rename = "RequesterAwsRegion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requester_aws_region: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutAggregationAuthorizationRequest {
#[serde(rename = "AuthorizedAccountId")]
pub authorized_account_id: String,
#[serde(rename = "AuthorizedAwsRegion")]
pub authorized_aws_region: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutAggregationAuthorizationResponse {
#[serde(rename = "AggregationAuthorization")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aggregation_authorization: Option<AggregationAuthorization>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutConfigRuleRequest {
#[serde(rename = "ConfigRule")]
pub config_rule: ConfigRule,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutConfigurationAggregatorRequest {
#[serde(rename = "AccountAggregationSources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_aggregation_sources: Option<Vec<AccountAggregationSource>>,
#[serde(rename = "ConfigurationAggregatorName")]
pub configuration_aggregator_name: String,
#[serde(rename = "OrganizationAggregationSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_aggregation_source: Option<OrganizationAggregationSource>,
#[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 PutConfigurationAggregatorResponse {
#[serde(rename = "ConfigurationAggregator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_aggregator: Option<ConfigurationAggregator>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutConfigurationRecorderRequest {
#[serde(rename = "ConfigurationRecorder")]
pub configuration_recorder: ConfigurationRecorder,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutConformancePackRequest {
#[serde(rename = "ConformancePackInputParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conformance_pack_input_parameters: Option<Vec<ConformancePackInputParameter>>,
#[serde(rename = "ConformancePackName")]
pub conformance_pack_name: String,
#[serde(rename = "DeliveryS3Bucket")]
pub delivery_s3_bucket: String,
#[serde(rename = "DeliveryS3KeyPrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delivery_s3_key_prefix: Option<String>,
#[serde(rename = "TemplateBody")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_body: Option<String>,
#[serde(rename = "TemplateS3Uri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_s3_uri: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutConformancePackResponse {
#[serde(rename = "ConformancePackArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conformance_pack_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutDeliveryChannelRequest {
#[serde(rename = "DeliveryChannel")]
pub delivery_channel: DeliveryChannel,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutEvaluationsRequest {
#[serde(rename = "Evaluations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub evaluations: Option<Vec<Evaluation>>,
#[serde(rename = "ResultToken")]
pub result_token: String,
#[serde(rename = "TestMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub test_mode: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutEvaluationsResponse {
#[serde(rename = "FailedEvaluations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed_evaluations: Option<Vec<Evaluation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutOrganizationConfigRuleRequest {
#[serde(rename = "ExcludedAccounts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub excluded_accounts: Option<Vec<String>>,
#[serde(rename = "OrganizationConfigRuleName")]
pub organization_config_rule_name: String,
#[serde(rename = "OrganizationCustomRuleMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_custom_rule_metadata: Option<OrganizationCustomRuleMetadata>,
#[serde(rename = "OrganizationManagedRuleMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_managed_rule_metadata: Option<OrganizationManagedRuleMetadata>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutOrganizationConfigRuleResponse {
#[serde(rename = "OrganizationConfigRuleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_config_rule_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutOrganizationConformancePackRequest {
#[serde(rename = "ConformancePackInputParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conformance_pack_input_parameters: Option<Vec<ConformancePackInputParameter>>,
#[serde(rename = "DeliveryS3Bucket")]
pub delivery_s3_bucket: String,
#[serde(rename = "DeliveryS3KeyPrefix")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delivery_s3_key_prefix: Option<String>,
#[serde(rename = "ExcludedAccounts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub excluded_accounts: Option<Vec<String>>,
#[serde(rename = "OrganizationConformancePackName")]
pub organization_conformance_pack_name: String,
#[serde(rename = "TemplateBody")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_body: Option<String>,
#[serde(rename = "TemplateS3Uri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_s3_uri: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutOrganizationConformancePackResponse {
#[serde(rename = "OrganizationConformancePackArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_conformance_pack_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutRemediationConfigurationsRequest {
#[serde(rename = "RemediationConfigurations")]
pub remediation_configurations: Vec<RemediationConfiguration>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutRemediationConfigurationsResponse {
#[serde(rename = "FailedBatches")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed_batches: Option<Vec<FailedRemediationBatch>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutRemediationExceptionsRequest {
#[serde(rename = "ConfigRuleName")]
pub config_rule_name: String,
#[serde(rename = "ExpirationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expiration_time: Option<f64>,
#[serde(rename = "Message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(rename = "ResourceKeys")]
pub resource_keys: Vec<RemediationExceptionResourceKey>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutRemediationExceptionsResponse {
#[serde(rename = "FailedBatches")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed_batches: Option<Vec<FailedRemediationExceptionBatch>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutResourceConfigRequest {
#[serde(rename = "Configuration")]
pub configuration: String,
#[serde(rename = "ResourceId")]
pub resource_id: String,
#[serde(rename = "ResourceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_name: Option<String>,
#[serde(rename = "ResourceType")]
pub resource_type: String,
#[serde(rename = "SchemaVersionId")]
pub schema_version_id: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutRetentionConfigurationRequest {
#[serde(rename = "RetentionPeriodInDays")]
pub retention_period_in_days: i64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutRetentionConfigurationResponse {
#[serde(rename = "RetentionConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retention_configuration: Option<RetentionConfiguration>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct QueryInfo {
#[serde(rename = "SelectFields")]
#[serde(skip_serializing_if = "Option::is_none")]
pub select_fields: Option<Vec<FieldInfo>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct RecordingGroup {
#[serde(rename = "allSupported")]
#[serde(skip_serializing_if = "Option::is_none")]
pub all_supported: Option<bool>,
#[serde(rename = "includeGlobalResourceTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub include_global_resource_types: Option<bool>,
#[serde(rename = "resourceTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_types: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Relationship {
#[serde(rename = "relationshipName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relationship_name: Option<String>,
#[serde(rename = "resourceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_id: Option<String>,
#[serde(rename = "resourceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_name: Option<String>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct RemediationConfiguration {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "Automatic")]
#[serde(skip_serializing_if = "Option::is_none")]
pub automatic: Option<bool>,
#[serde(rename = "ConfigRuleName")]
pub config_rule_name: String,
#[serde(rename = "CreatedByService")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_by_service: Option<String>,
#[serde(rename = "ExecutionControls")]
#[serde(skip_serializing_if = "Option::is_none")]
pub execution_controls: Option<ExecutionControls>,
#[serde(rename = "MaximumAutomaticAttempts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum_automatic_attempts: Option<i64>,
#[serde(rename = "Parameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameters: Option<::std::collections::HashMap<String, RemediationParameterValue>>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "RetryAttemptSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retry_attempt_seconds: Option<i64>,
#[serde(rename = "TargetId")]
pub target_id: String,
#[serde(rename = "TargetType")]
pub target_type: String,
#[serde(rename = "TargetVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RemediationException {
#[serde(rename = "ConfigRuleName")]
pub config_rule_name: String,
#[serde(rename = "ExpirationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expiration_time: Option<f64>,
#[serde(rename = "Message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(rename = "ResourceId")]
pub resource_id: String,
#[serde(rename = "ResourceType")]
pub resource_type: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct RemediationExceptionResourceKey {
#[serde(rename = "ResourceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_id: Option<String>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RemediationExecutionStatus {
#[serde(rename = "InvocationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub invocation_time: Option<f64>,
#[serde(rename = "LastUpdatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_time: Option<f64>,
#[serde(rename = "ResourceKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_key: Option<ResourceKey>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "StepDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub step_details: Option<Vec<RemediationExecutionStep>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RemediationExecutionStep {
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "StartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "StopTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stop_time: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct RemediationParameterValue {
#[serde(rename = "ResourceValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_value: Option<ResourceValue>,
#[serde(rename = "StaticValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub static_value: Option<StaticValue>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResourceCount {
#[serde(rename = "count")]
#[serde(skip_serializing_if = "Option::is_none")]
pub count: Option<i64>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ResourceCountFilters {
#[serde(rename = "AccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_id: Option<String>,
#[serde(rename = "Region")]
#[serde(skip_serializing_if = "Option::is_none")]
pub region: Option<String>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ResourceFilters {
#[serde(rename = "AccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_id: Option<String>,
#[serde(rename = "Region")]
#[serde(skip_serializing_if = "Option::is_none")]
pub region: Option<String>,
#[serde(rename = "ResourceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_id: Option<String>,
#[serde(rename = "ResourceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResourceIdentifier {
#[serde(rename = "resourceDeletionTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_deletion_time: Option<f64>,
#[serde(rename = "resourceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_id: Option<String>,
#[serde(rename = "resourceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_name: Option<String>,
#[serde(rename = "resourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ResourceKey {
#[serde(rename = "resourceId")]
pub resource_id: String,
#[serde(rename = "resourceType")]
pub resource_type: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ResourceValue {
#[serde(rename = "Value")]
pub value: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RetentionConfiguration {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "RetentionPeriodInDays")]
pub retention_period_in_days: i64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Scope {
#[serde(rename = "ComplianceResourceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compliance_resource_id: Option<String>,
#[serde(rename = "ComplianceResourceTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compliance_resource_types: Option<Vec<String>>,
#[serde(rename = "TagKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tag_key: Option<String>,
#[serde(rename = "TagValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tag_value: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SelectAggregateResourceConfigRequest {
#[serde(rename = "ConfigurationAggregatorName")]
pub configuration_aggregator_name: String,
#[serde(rename = "Expression")]
pub expression: String,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[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 SelectAggregateResourceConfigResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "QueryInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub query_info: Option<QueryInfo>,
#[serde(rename = "Results")]
#[serde(skip_serializing_if = "Option::is_none")]
pub results: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SelectResourceConfigRequest {
#[serde(rename = "Expression")]
pub expression: String,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SelectResourceConfigResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "QueryInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub query_info: Option<QueryInfo>,
#[serde(rename = "Results")]
#[serde(skip_serializing_if = "Option::is_none")]
pub results: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Source {
#[serde(rename = "Owner")]
pub owner: String,
#[serde(rename = "SourceDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_details: Option<Vec<SourceDetail>>,
#[serde(rename = "SourceIdentifier")]
pub source_identifier: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SourceDetail {
#[serde(rename = "EventSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_source: Option<String>,
#[serde(rename = "MaximumExecutionFrequency")]
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum_execution_frequency: Option<String>,
#[serde(rename = "MessageType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SsmControls {
#[serde(rename = "ConcurrentExecutionRatePercentage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub concurrent_execution_rate_percentage: Option<i64>,
#[serde(rename = "ErrorPercentage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_percentage: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartConfigRulesEvaluationRequest {
#[serde(rename = "ConfigRuleNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub config_rule_names: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartConfigRulesEvaluationResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartConfigurationRecorderRequest {
#[serde(rename = "ConfigurationRecorderName")]
pub configuration_recorder_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartRemediationExecutionRequest {
#[serde(rename = "ConfigRuleName")]
pub config_rule_name: String,
#[serde(rename = "ResourceKeys")]
pub resource_keys: Vec<ResourceKey>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartRemediationExecutionResponse {
#[serde(rename = "FailedItems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed_items: Option<Vec<ResourceKey>>,
#[serde(rename = "FailureMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_message: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct StaticValue {
#[serde(rename = "Values")]
pub values: Vec<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StatusDetailFilters {
#[serde(rename = "AccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_id: Option<String>,
#[serde(rename = "MemberAccountRuleStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub member_account_rule_status: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopConfigurationRecorderRequest {
#[serde(rename = "ConfigurationRecorderName")]
pub configuration_recorder_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Tag {
#[serde(rename = "Key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key: Option<String>,
#[serde(rename = "Value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "Tags")]
pub tags: Vec<Tag>,
}
#[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(Debug, PartialEq)]
pub enum BatchGetAggregateResourceConfigError {
NoSuchConfigurationAggregator(String),
}
impl BatchGetAggregateResourceConfigError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<BatchGetAggregateResourceConfigError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"NoSuchConfigurationAggregatorException" => {
return RusotoError::Service(
BatchGetAggregateResourceConfigError::NoSuchConfigurationAggregator(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BatchGetAggregateResourceConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchGetAggregateResourceConfigError::NoSuchConfigurationAggregator(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for BatchGetAggregateResourceConfigError {}
#[derive(Debug, PartialEq)]
pub enum BatchGetResourceConfigError {
NoAvailableConfigurationRecorder(String),
}
impl BatchGetResourceConfigError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<BatchGetResourceConfigError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"NoAvailableConfigurationRecorderException" => {
return RusotoError::Service(
BatchGetResourceConfigError::NoAvailableConfigurationRecorder(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BatchGetResourceConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchGetResourceConfigError::NoAvailableConfigurationRecorder(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for BatchGetResourceConfigError {}
#[derive(Debug, PartialEq)]
pub enum DeleteAggregationAuthorizationError {
InvalidParameterValue(String),
}
impl DeleteAggregationAuthorizationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteAggregationAuthorizationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
DeleteAggregationAuthorizationError::InvalidParameterValue(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteAggregationAuthorizationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteAggregationAuthorizationError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteAggregationAuthorizationError {}
#[derive(Debug, PartialEq)]
pub enum DeleteConfigRuleError {
NoSuchConfigRule(String),
ResourceInUse(String),
}
impl DeleteConfigRuleError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteConfigRuleError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"NoSuchConfigRuleException" => {
return RusotoError::Service(DeleteConfigRuleError::NoSuchConfigRule(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(DeleteConfigRuleError::ResourceInUse(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteConfigRuleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteConfigRuleError::NoSuchConfigRule(ref cause) => write!(f, "{}", cause),
DeleteConfigRuleError::ResourceInUse(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteConfigRuleError {}
#[derive(Debug, PartialEq)]
pub enum DeleteConfigurationAggregatorError {
NoSuchConfigurationAggregator(String),
}
impl DeleteConfigurationAggregatorError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteConfigurationAggregatorError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"NoSuchConfigurationAggregatorException" => {
return RusotoError::Service(
DeleteConfigurationAggregatorError::NoSuchConfigurationAggregator(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteConfigurationAggregatorError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteConfigurationAggregatorError::NoSuchConfigurationAggregator(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteConfigurationAggregatorError {}
#[derive(Debug, PartialEq)]
pub enum DeleteConfigurationRecorderError {
NoSuchConfigurationRecorder(String),
}
impl DeleteConfigurationRecorderError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteConfigurationRecorderError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"NoSuchConfigurationRecorderException" => {
return RusotoError::Service(
DeleteConfigurationRecorderError::NoSuchConfigurationRecorder(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteConfigurationRecorderError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteConfigurationRecorderError::NoSuchConfigurationRecorder(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteConfigurationRecorderError {}
#[derive(Debug, PartialEq)]
pub enum DeleteConformancePackError {
NoSuchConformancePack(String),
ResourceInUse(String),
}
impl DeleteConformancePackError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteConformancePackError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"NoSuchConformancePackException" => {
return RusotoError::Service(DeleteConformancePackError::NoSuchConformancePack(
err.msg,
))
}
"ResourceInUseException" => {
return RusotoError::Service(DeleteConformancePackError::ResourceInUse(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteConformancePackError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteConformancePackError::NoSuchConformancePack(ref cause) => write!(f, "{}", cause),
DeleteConformancePackError::ResourceInUse(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteConformancePackError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDeliveryChannelError {
LastDeliveryChannelDeleteFailed(String),
NoSuchDeliveryChannel(String),
}
impl DeleteDeliveryChannelError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDeliveryChannelError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"LastDeliveryChannelDeleteFailedException" => {
return RusotoError::Service(
DeleteDeliveryChannelError::LastDeliveryChannelDeleteFailed(err.msg),
)
}
"NoSuchDeliveryChannelException" => {
return RusotoError::Service(DeleteDeliveryChannelError::NoSuchDeliveryChannel(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDeliveryChannelError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDeliveryChannelError::LastDeliveryChannelDeleteFailed(ref cause) => {
write!(f, "{}", cause)
}
DeleteDeliveryChannelError::NoSuchDeliveryChannel(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDeliveryChannelError {}
#[derive(Debug, PartialEq)]
pub enum DeleteEvaluationResultsError {
NoSuchConfigRule(String),
ResourceInUse(String),
}
impl DeleteEvaluationResultsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteEvaluationResultsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"NoSuchConfigRuleException" => {
return RusotoError::Service(DeleteEvaluationResultsError::NoSuchConfigRule(
err.msg,
))
}
"ResourceInUseException" => {
return RusotoError::Service(DeleteEvaluationResultsError::ResourceInUse(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteEvaluationResultsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteEvaluationResultsError::NoSuchConfigRule(ref cause) => write!(f, "{}", cause),
DeleteEvaluationResultsError::ResourceInUse(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteEvaluationResultsError {}
#[derive(Debug, PartialEq)]
pub enum DeleteOrganizationConfigRuleError {
NoSuchOrganizationConfigRule(String),
OrganizationAccessDenied(String),
ResourceInUse(String),
}
impl DeleteOrganizationConfigRuleError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteOrganizationConfigRuleError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"NoSuchOrganizationConfigRuleException" => {
return RusotoError::Service(
DeleteOrganizationConfigRuleError::NoSuchOrganizationConfigRule(err.msg),
)
}
"OrganizationAccessDeniedException" => {
return RusotoError::Service(
DeleteOrganizationConfigRuleError::OrganizationAccessDenied(err.msg),
)
}
"ResourceInUseException" => {
return RusotoError::Service(DeleteOrganizationConfigRuleError::ResourceInUse(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteOrganizationConfigRuleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteOrganizationConfigRuleError::NoSuchOrganizationConfigRule(ref cause) => {
write!(f, "{}", cause)
}
DeleteOrganizationConfigRuleError::OrganizationAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
DeleteOrganizationConfigRuleError::ResourceInUse(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteOrganizationConfigRuleError {}
#[derive(Debug, PartialEq)]
pub enum DeleteOrganizationConformancePackError {
NoSuchOrganizationConformancePack(String),
OrganizationAccessDenied(String),
ResourceInUse(String),
}
impl DeleteOrganizationConformancePackError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteOrganizationConformancePackError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"NoSuchOrganizationConformancePackException" => {
return RusotoError::Service(
DeleteOrganizationConformancePackError::NoSuchOrganizationConformancePack(
err.msg,
),
)
}
"OrganizationAccessDeniedException" => {
return RusotoError::Service(
DeleteOrganizationConformancePackError::OrganizationAccessDenied(err.msg),
)
}
"ResourceInUseException" => {
return RusotoError::Service(
DeleteOrganizationConformancePackError::ResourceInUse(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteOrganizationConformancePackError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteOrganizationConformancePackError::NoSuchOrganizationConformancePack(
ref cause,
) => write!(f, "{}", cause),
DeleteOrganizationConformancePackError::OrganizationAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
DeleteOrganizationConformancePackError::ResourceInUse(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteOrganizationConformancePackError {}
#[derive(Debug, PartialEq)]
pub enum DeletePendingAggregationRequestError {
InvalidParameterValue(String),
}
impl DeletePendingAggregationRequestError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeletePendingAggregationRequestError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
DeletePendingAggregationRequestError::InvalidParameterValue(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeletePendingAggregationRequestError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeletePendingAggregationRequestError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeletePendingAggregationRequestError {}
#[derive(Debug, PartialEq)]
pub enum DeleteRemediationConfigurationError {
InsufficientPermissions(String),
NoSuchRemediationConfiguration(String),
RemediationInProgress(String),
}
impl DeleteRemediationConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteRemediationConfigurationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InsufficientPermissionsException" => {
return RusotoError::Service(
DeleteRemediationConfigurationError::InsufficientPermissions(err.msg),
)
}
"NoSuchRemediationConfigurationException" => {
return RusotoError::Service(
DeleteRemediationConfigurationError::NoSuchRemediationConfiguration(
err.msg,
),
)
}
"RemediationInProgressException" => {
return RusotoError::Service(
DeleteRemediationConfigurationError::RemediationInProgress(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteRemediationConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteRemediationConfigurationError::InsufficientPermissions(ref cause) => {
write!(f, "{}", cause)
}
DeleteRemediationConfigurationError::NoSuchRemediationConfiguration(ref cause) => {
write!(f, "{}", cause)
}
DeleteRemediationConfigurationError::RemediationInProgress(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteRemediationConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum DeleteRemediationExceptionsError {
NoSuchRemediation(String),
}
impl DeleteRemediationExceptionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteRemediationExceptionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"NoSuchRemediationExceptionException" => {
return RusotoError::Service(
DeleteRemediationExceptionsError::NoSuchRemediation(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteRemediationExceptionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteRemediationExceptionsError::NoSuchRemediation(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteRemediationExceptionsError {}
#[derive(Debug, PartialEq)]
pub enum DeleteResourceConfigError {
NoRunningConfigurationRecorder(String),
}
impl DeleteResourceConfigError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteResourceConfigError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"NoRunningConfigurationRecorderException" => {
return RusotoError::Service(
DeleteResourceConfigError::NoRunningConfigurationRecorder(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteResourceConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteResourceConfigError::NoRunningConfigurationRecorder(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteResourceConfigError {}
#[derive(Debug, PartialEq)]
pub enum DeleteRetentionConfigurationError {
InvalidParameterValue(String),
NoSuchRetentionConfiguration(String),
}
impl DeleteRetentionConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteRetentionConfigurationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
DeleteRetentionConfigurationError::InvalidParameterValue(err.msg),
)
}
"NoSuchRetentionConfigurationException" => {
return RusotoError::Service(
DeleteRetentionConfigurationError::NoSuchRetentionConfiguration(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteRetentionConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteRetentionConfigurationError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
DeleteRetentionConfigurationError::NoSuchRetentionConfiguration(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteRetentionConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum DeliverConfigSnapshotError {
NoAvailableConfigurationRecorder(String),
NoRunningConfigurationRecorder(String),
NoSuchDeliveryChannel(String),
}
impl DeliverConfigSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeliverConfigSnapshotError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"NoAvailableConfigurationRecorderException" => {
return RusotoError::Service(
DeliverConfigSnapshotError::NoAvailableConfigurationRecorder(err.msg),
)
}
"NoRunningConfigurationRecorderException" => {
return RusotoError::Service(
DeliverConfigSnapshotError::NoRunningConfigurationRecorder(err.msg),
)
}
"NoSuchDeliveryChannelException" => {
return RusotoError::Service(DeliverConfigSnapshotError::NoSuchDeliveryChannel(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeliverConfigSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeliverConfigSnapshotError::NoAvailableConfigurationRecorder(ref cause) => {
write!(f, "{}", cause)
}
DeliverConfigSnapshotError::NoRunningConfigurationRecorder(ref cause) => {
write!(f, "{}", cause)
}
DeliverConfigSnapshotError::NoSuchDeliveryChannel(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeliverConfigSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum DescribeAggregateComplianceByConfigRulesError {
InvalidLimit(String),
InvalidNextToken(String),
NoSuchConfigurationAggregator(String),
}
impl DescribeAggregateComplianceByConfigRulesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeAggregateComplianceByConfigRulesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidLimitException" => {
return RusotoError::Service(
DescribeAggregateComplianceByConfigRulesError::InvalidLimit(err.msg),
)
}
"InvalidNextTokenException" => {
return RusotoError::Service(
DescribeAggregateComplianceByConfigRulesError::InvalidNextToken(err.msg),
)
}
"NoSuchConfigurationAggregatorException" => return RusotoError::Service(
DescribeAggregateComplianceByConfigRulesError::NoSuchConfigurationAggregator(
err.msg,
),
),
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeAggregateComplianceByConfigRulesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeAggregateComplianceByConfigRulesError::InvalidLimit(ref cause) => {
write!(f, "{}", cause)
}
DescribeAggregateComplianceByConfigRulesError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
DescribeAggregateComplianceByConfigRulesError::NoSuchConfigurationAggregator(
ref cause,
) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeAggregateComplianceByConfigRulesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeAggregationAuthorizationsError {
InvalidLimit(String),
InvalidNextToken(String),
InvalidParameterValue(String),
}
impl DescribeAggregationAuthorizationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeAggregationAuthorizationsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidLimitException" => {
return RusotoError::Service(
DescribeAggregationAuthorizationsError::InvalidLimit(err.msg),
)
}
"InvalidNextTokenException" => {
return RusotoError::Service(
DescribeAggregationAuthorizationsError::InvalidNextToken(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
DescribeAggregationAuthorizationsError::InvalidParameterValue(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeAggregationAuthorizationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeAggregationAuthorizationsError::InvalidLimit(ref cause) => {
write!(f, "{}", cause)
}
DescribeAggregationAuthorizationsError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
DescribeAggregationAuthorizationsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeAggregationAuthorizationsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeComplianceByConfigRuleError {
InvalidNextToken(String),
InvalidParameterValue(String),
NoSuchConfigRule(String),
}
impl DescribeComplianceByConfigRuleError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeComplianceByConfigRuleError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(
DescribeComplianceByConfigRuleError::InvalidNextToken(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
DescribeComplianceByConfigRuleError::InvalidParameterValue(err.msg),
)
}
"NoSuchConfigRuleException" => {
return RusotoError::Service(
DescribeComplianceByConfigRuleError::NoSuchConfigRule(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeComplianceByConfigRuleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeComplianceByConfigRuleError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
DescribeComplianceByConfigRuleError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
DescribeComplianceByConfigRuleError::NoSuchConfigRule(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeComplianceByConfigRuleError {}
#[derive(Debug, PartialEq)]
pub enum DescribeComplianceByResourceError {
InvalidNextToken(String),
InvalidParameterValue(String),
}
impl DescribeComplianceByResourceError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeComplianceByResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(
DescribeComplianceByResourceError::InvalidNextToken(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
DescribeComplianceByResourceError::InvalidParameterValue(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeComplianceByResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeComplianceByResourceError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
DescribeComplianceByResourceError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeComplianceByResourceError {}
#[derive(Debug, PartialEq)]
pub enum DescribeConfigRuleEvaluationStatusError {
InvalidNextToken(String),
InvalidParameterValue(String),
NoSuchConfigRule(String),
}
impl DescribeConfigRuleEvaluationStatusError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeConfigRuleEvaluationStatusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(
DescribeConfigRuleEvaluationStatusError::InvalidNextToken(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
DescribeConfigRuleEvaluationStatusError::InvalidParameterValue(err.msg),
)
}
"NoSuchConfigRuleException" => {
return RusotoError::Service(
DescribeConfigRuleEvaluationStatusError::NoSuchConfigRule(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeConfigRuleEvaluationStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeConfigRuleEvaluationStatusError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
DescribeConfigRuleEvaluationStatusError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
DescribeConfigRuleEvaluationStatusError::NoSuchConfigRule(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeConfigRuleEvaluationStatusError {}
#[derive(Debug, PartialEq)]
pub enum DescribeConfigRulesError {
InvalidNextToken(String),
NoSuchConfigRule(String),
}
impl DescribeConfigRulesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeConfigRulesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(DescribeConfigRulesError::InvalidNextToken(
err.msg,
))
}
"NoSuchConfigRuleException" => {
return RusotoError::Service(DescribeConfigRulesError::NoSuchConfigRule(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeConfigRulesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeConfigRulesError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
DescribeConfigRulesError::NoSuchConfigRule(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeConfigRulesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeConfigurationAggregatorSourcesStatusError {
InvalidLimit(String),
InvalidNextToken(String),
InvalidParameterValue(String),
NoSuchConfigurationAggregator(String),
}
impl DescribeConfigurationAggregatorSourcesStatusError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeConfigurationAggregatorSourcesStatusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidLimitException" => return RusotoError::Service(DescribeConfigurationAggregatorSourcesStatusError::InvalidLimit(err.msg)),
"InvalidNextTokenException" => return RusotoError::Service(DescribeConfigurationAggregatorSourcesStatusError::InvalidNextToken(err.msg)),
"InvalidParameterValueException" => return RusotoError::Service(DescribeConfigurationAggregatorSourcesStatusError::InvalidParameterValue(err.msg)),
"NoSuchConfigurationAggregatorException" => return RusotoError::Service(DescribeConfigurationAggregatorSourcesStatusError::NoSuchConfigurationAggregator(err.msg)),
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeConfigurationAggregatorSourcesStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeConfigurationAggregatorSourcesStatusError::InvalidLimit(ref cause) => {
write!(f, "{}", cause)
}
DescribeConfigurationAggregatorSourcesStatusError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
DescribeConfigurationAggregatorSourcesStatusError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
DescribeConfigurationAggregatorSourcesStatusError::NoSuchConfigurationAggregator(
ref cause,
) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeConfigurationAggregatorSourcesStatusError {}
#[derive(Debug, PartialEq)]
pub enum DescribeConfigurationAggregatorsError {
InvalidLimit(String),
InvalidNextToken(String),
InvalidParameterValue(String),
NoSuchConfigurationAggregator(String),
}
impl DescribeConfigurationAggregatorsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeConfigurationAggregatorsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidLimitException" => {
return RusotoError::Service(
DescribeConfigurationAggregatorsError::InvalidLimit(err.msg),
)
}
"InvalidNextTokenException" => {
return RusotoError::Service(
DescribeConfigurationAggregatorsError::InvalidNextToken(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
DescribeConfigurationAggregatorsError::InvalidParameterValue(err.msg),
)
}
"NoSuchConfigurationAggregatorException" => {
return RusotoError::Service(
DescribeConfigurationAggregatorsError::NoSuchConfigurationAggregator(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeConfigurationAggregatorsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeConfigurationAggregatorsError::InvalidLimit(ref cause) => {
write!(f, "{}", cause)
}
DescribeConfigurationAggregatorsError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
DescribeConfigurationAggregatorsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
DescribeConfigurationAggregatorsError::NoSuchConfigurationAggregator(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeConfigurationAggregatorsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeConfigurationRecorderStatusError {
NoSuchConfigurationRecorder(String),
}
impl DescribeConfigurationRecorderStatusError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeConfigurationRecorderStatusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"NoSuchConfigurationRecorderException" => {
return RusotoError::Service(
DescribeConfigurationRecorderStatusError::NoSuchConfigurationRecorder(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeConfigurationRecorderStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeConfigurationRecorderStatusError::NoSuchConfigurationRecorder(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeConfigurationRecorderStatusError {}
#[derive(Debug, PartialEq)]
pub enum DescribeConfigurationRecordersError {
NoSuchConfigurationRecorder(String),
}
impl DescribeConfigurationRecordersError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeConfigurationRecordersError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"NoSuchConfigurationRecorderException" => {
return RusotoError::Service(
DescribeConfigurationRecordersError::NoSuchConfigurationRecorder(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeConfigurationRecordersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeConfigurationRecordersError::NoSuchConfigurationRecorder(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeConfigurationRecordersError {}
#[derive(Debug, PartialEq)]
pub enum DescribeConformancePackComplianceError {
InvalidLimit(String),
InvalidNextToken(String),
InvalidParameterValue(String),
NoSuchConfigRuleInConformancePack(String),
NoSuchConformancePack(String),
}
impl DescribeConformancePackComplianceError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeConformancePackComplianceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidLimitException" => {
return RusotoError::Service(
DescribeConformancePackComplianceError::InvalidLimit(err.msg),
)
}
"InvalidNextTokenException" => {
return RusotoError::Service(
DescribeConformancePackComplianceError::InvalidNextToken(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
DescribeConformancePackComplianceError::InvalidParameterValue(err.msg),
)
}
"NoSuchConfigRuleInConformancePackException" => {
return RusotoError::Service(
DescribeConformancePackComplianceError::NoSuchConfigRuleInConformancePack(
err.msg,
),
)
}
"NoSuchConformancePackException" => {
return RusotoError::Service(
DescribeConformancePackComplianceError::NoSuchConformancePack(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeConformancePackComplianceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeConformancePackComplianceError::InvalidLimit(ref cause) => {
write!(f, "{}", cause)
}
DescribeConformancePackComplianceError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
DescribeConformancePackComplianceError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
DescribeConformancePackComplianceError::NoSuchConfigRuleInConformancePack(
ref cause,
) => write!(f, "{}", cause),
DescribeConformancePackComplianceError::NoSuchConformancePack(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeConformancePackComplianceError {}
#[derive(Debug, PartialEq)]
pub enum DescribeConformancePackStatusError {
InvalidLimit(String),
InvalidNextToken(String),
}
impl DescribeConformancePackStatusError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeConformancePackStatusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidLimitException" => {
return RusotoError::Service(DescribeConformancePackStatusError::InvalidLimit(
err.msg,
))
}
"InvalidNextTokenException" => {
return RusotoError::Service(
DescribeConformancePackStatusError::InvalidNextToken(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeConformancePackStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeConformancePackStatusError::InvalidLimit(ref cause) => write!(f, "{}", cause),
DescribeConformancePackStatusError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeConformancePackStatusError {}
#[derive(Debug, PartialEq)]
pub enum DescribeConformancePacksError {
InvalidLimit(String),
InvalidNextToken(String),
NoSuchConformancePack(String),
}
impl DescribeConformancePacksError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeConformancePacksError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidLimitException" => {
return RusotoError::Service(DescribeConformancePacksError::InvalidLimit(
err.msg,
))
}
"InvalidNextTokenException" => {
return RusotoError::Service(DescribeConformancePacksError::InvalidNextToken(
err.msg,
))
}
"NoSuchConformancePackException" => {
return RusotoError::Service(
DescribeConformancePacksError::NoSuchConformancePack(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeConformancePacksError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeConformancePacksError::InvalidLimit(ref cause) => write!(f, "{}", cause),
DescribeConformancePacksError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
DescribeConformancePacksError::NoSuchConformancePack(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeConformancePacksError {}
#[derive(Debug, PartialEq)]
pub enum DescribeDeliveryChannelStatusError {
NoSuchDeliveryChannel(String),
}
impl DescribeDeliveryChannelStatusError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeDeliveryChannelStatusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"NoSuchDeliveryChannelException" => {
return RusotoError::Service(
DescribeDeliveryChannelStatusError::NoSuchDeliveryChannel(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeDeliveryChannelStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeDeliveryChannelStatusError::NoSuchDeliveryChannel(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeDeliveryChannelStatusError {}
#[derive(Debug, PartialEq)]
pub enum DescribeDeliveryChannelsError {
NoSuchDeliveryChannel(String),
}
impl DescribeDeliveryChannelsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeDeliveryChannelsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"NoSuchDeliveryChannelException" => {
return RusotoError::Service(
DescribeDeliveryChannelsError::NoSuchDeliveryChannel(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeDeliveryChannelsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeDeliveryChannelsError::NoSuchDeliveryChannel(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeDeliveryChannelsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeOrganizationConfigRuleStatusesError {
InvalidLimit(String),
InvalidNextToken(String),
NoSuchOrganizationConfigRule(String),
OrganizationAccessDenied(String),
}
impl DescribeOrganizationConfigRuleStatusesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeOrganizationConfigRuleStatusesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidLimitException" => {
return RusotoError::Service(
DescribeOrganizationConfigRuleStatusesError::InvalidLimit(err.msg),
)
}
"InvalidNextTokenException" => {
return RusotoError::Service(
DescribeOrganizationConfigRuleStatusesError::InvalidNextToken(err.msg),
)
}
"NoSuchOrganizationConfigRuleException" => {
return RusotoError::Service(
DescribeOrganizationConfigRuleStatusesError::NoSuchOrganizationConfigRule(
err.msg,
),
)
}
"OrganizationAccessDeniedException" => {
return RusotoError::Service(
DescribeOrganizationConfigRuleStatusesError::OrganizationAccessDenied(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeOrganizationConfigRuleStatusesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeOrganizationConfigRuleStatusesError::InvalidLimit(ref cause) => {
write!(f, "{}", cause)
}
DescribeOrganizationConfigRuleStatusesError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
DescribeOrganizationConfigRuleStatusesError::NoSuchOrganizationConfigRule(
ref cause,
) => write!(f, "{}", cause),
DescribeOrganizationConfigRuleStatusesError::OrganizationAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeOrganizationConfigRuleStatusesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeOrganizationConfigRulesError {
InvalidLimit(String),
InvalidNextToken(String),
NoSuchOrganizationConfigRule(String),
OrganizationAccessDenied(String),
}
impl DescribeOrganizationConfigRulesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeOrganizationConfigRulesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidLimitException" => {
return RusotoError::Service(
DescribeOrganizationConfigRulesError::InvalidLimit(err.msg),
)
}
"InvalidNextTokenException" => {
return RusotoError::Service(
DescribeOrganizationConfigRulesError::InvalidNextToken(err.msg),
)
}
"NoSuchOrganizationConfigRuleException" => {
return RusotoError::Service(
DescribeOrganizationConfigRulesError::NoSuchOrganizationConfigRule(err.msg),
)
}
"OrganizationAccessDeniedException" => {
return RusotoError::Service(
DescribeOrganizationConfigRulesError::OrganizationAccessDenied(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeOrganizationConfigRulesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeOrganizationConfigRulesError::InvalidLimit(ref cause) => write!(f, "{}", cause),
DescribeOrganizationConfigRulesError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
DescribeOrganizationConfigRulesError::NoSuchOrganizationConfigRule(ref cause) => {
write!(f, "{}", cause)
}
DescribeOrganizationConfigRulesError::OrganizationAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeOrganizationConfigRulesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeOrganizationConformancePackStatusesError {
InvalidLimit(String),
InvalidNextToken(String),
NoSuchOrganizationConformancePack(String),
OrganizationAccessDenied(String),
}
impl DescribeOrganizationConformancePackStatusesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeOrganizationConformancePackStatusesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidLimitException" => return RusotoError::Service(DescribeOrganizationConformancePackStatusesError::InvalidLimit(err.msg)),
"InvalidNextTokenException" => return RusotoError::Service(DescribeOrganizationConformancePackStatusesError::InvalidNextToken(err.msg)),
"NoSuchOrganizationConformancePackException" => return RusotoError::Service(DescribeOrganizationConformancePackStatusesError::NoSuchOrganizationConformancePack(err.msg)),
"OrganizationAccessDeniedException" => return RusotoError::Service(DescribeOrganizationConformancePackStatusesError::OrganizationAccessDenied(err.msg)),
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeOrganizationConformancePackStatusesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeOrganizationConformancePackStatusesError::InvalidLimit(ref cause) => {
write!(f, "{}", cause)
}
DescribeOrganizationConformancePackStatusesError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
DescribeOrganizationConformancePackStatusesError::NoSuchOrganizationConformancePack(
ref cause,
) => write!(f, "{}", cause),
DescribeOrganizationConformancePackStatusesError::OrganizationAccessDenied(
ref cause,
) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeOrganizationConformancePackStatusesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeOrganizationConformancePacksError {
InvalidLimit(String),
InvalidNextToken(String),
NoSuchOrganizationConformancePack(String),
OrganizationAccessDenied(String),
}
impl DescribeOrganizationConformancePacksError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeOrganizationConformancePacksError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidLimitException" => {
return RusotoError::Service(
DescribeOrganizationConformancePacksError::InvalidLimit(err.msg),
)
}
"InvalidNextTokenException" => {
return RusotoError::Service(
DescribeOrganizationConformancePacksError::InvalidNextToken(err.msg),
)
}
"NoSuchOrganizationConformancePackException" => return RusotoError::Service(
DescribeOrganizationConformancePacksError::NoSuchOrganizationConformancePack(
err.msg,
),
),
"OrganizationAccessDeniedException" => {
return RusotoError::Service(
DescribeOrganizationConformancePacksError::OrganizationAccessDenied(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeOrganizationConformancePacksError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeOrganizationConformancePacksError::InvalidLimit(ref cause) => {
write!(f, "{}", cause)
}
DescribeOrganizationConformancePacksError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
DescribeOrganizationConformancePacksError::NoSuchOrganizationConformancePack(
ref cause,
) => write!(f, "{}", cause),
DescribeOrganizationConformancePacksError::OrganizationAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeOrganizationConformancePacksError {}
#[derive(Debug, PartialEq)]
pub enum DescribePendingAggregationRequestsError {
InvalidLimit(String),
InvalidNextToken(String),
InvalidParameterValue(String),
}
impl DescribePendingAggregationRequestsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribePendingAggregationRequestsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidLimitException" => {
return RusotoError::Service(
DescribePendingAggregationRequestsError::InvalidLimit(err.msg),
)
}
"InvalidNextTokenException" => {
return RusotoError::Service(
DescribePendingAggregationRequestsError::InvalidNextToken(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
DescribePendingAggregationRequestsError::InvalidParameterValue(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribePendingAggregationRequestsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribePendingAggregationRequestsError::InvalidLimit(ref cause) => {
write!(f, "{}", cause)
}
DescribePendingAggregationRequestsError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
DescribePendingAggregationRequestsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribePendingAggregationRequestsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeRemediationConfigurationsError {}
impl DescribeRemediationConfigurationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeRemediationConfigurationsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeRemediationConfigurationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for DescribeRemediationConfigurationsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeRemediationExceptionsError {
InvalidNextToken(String),
InvalidParameterValue(String),
}
impl DescribeRemediationExceptionsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeRemediationExceptionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(
DescribeRemediationExceptionsError::InvalidNextToken(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
DescribeRemediationExceptionsError::InvalidParameterValue(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeRemediationExceptionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeRemediationExceptionsError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
DescribeRemediationExceptionsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeRemediationExceptionsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeRemediationExecutionStatusError {
InvalidNextToken(String),
NoSuchRemediationConfiguration(String),
}
impl DescribeRemediationExecutionStatusError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeRemediationExecutionStatusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(
DescribeRemediationExecutionStatusError::InvalidNextToken(err.msg),
)
}
"NoSuchRemediationConfigurationException" => {
return RusotoError::Service(
DescribeRemediationExecutionStatusError::NoSuchRemediationConfiguration(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeRemediationExecutionStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeRemediationExecutionStatusError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
DescribeRemediationExecutionStatusError::NoSuchRemediationConfiguration(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeRemediationExecutionStatusError {}
#[derive(Debug, PartialEq)]
pub enum DescribeRetentionConfigurationsError {
InvalidNextToken(String),
InvalidParameterValue(String),
NoSuchRetentionConfiguration(String),
}
impl DescribeRetentionConfigurationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeRetentionConfigurationsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(
DescribeRetentionConfigurationsError::InvalidNextToken(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
DescribeRetentionConfigurationsError::InvalidParameterValue(err.msg),
)
}
"NoSuchRetentionConfigurationException" => {
return RusotoError::Service(
DescribeRetentionConfigurationsError::NoSuchRetentionConfiguration(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeRetentionConfigurationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeRetentionConfigurationsError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
DescribeRetentionConfigurationsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
DescribeRetentionConfigurationsError::NoSuchRetentionConfiguration(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeRetentionConfigurationsError {}
#[derive(Debug, PartialEq)]
pub enum GetAggregateComplianceDetailsByConfigRuleError {
InvalidLimit(String),
InvalidNextToken(String),
NoSuchConfigurationAggregator(String),
}
impl GetAggregateComplianceDetailsByConfigRuleError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetAggregateComplianceDetailsByConfigRuleError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidLimitException" => {
return RusotoError::Service(
GetAggregateComplianceDetailsByConfigRuleError::InvalidLimit(err.msg),
)
}
"InvalidNextTokenException" => {
return RusotoError::Service(
GetAggregateComplianceDetailsByConfigRuleError::InvalidNextToken(err.msg),
)
}
"NoSuchConfigurationAggregatorException" => return RusotoError::Service(
GetAggregateComplianceDetailsByConfigRuleError::NoSuchConfigurationAggregator(
err.msg,
),
),
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetAggregateComplianceDetailsByConfigRuleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetAggregateComplianceDetailsByConfigRuleError::InvalidLimit(ref cause) => {
write!(f, "{}", cause)
}
GetAggregateComplianceDetailsByConfigRuleError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
GetAggregateComplianceDetailsByConfigRuleError::NoSuchConfigurationAggregator(
ref cause,
) => write!(f, "{}", cause),
}
}
}
impl Error for GetAggregateComplianceDetailsByConfigRuleError {}
#[derive(Debug, PartialEq)]
pub enum GetAggregateConfigRuleComplianceSummaryError {
InvalidLimit(String),
InvalidNextToken(String),
NoSuchConfigurationAggregator(String),
}
impl GetAggregateConfigRuleComplianceSummaryError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetAggregateConfigRuleComplianceSummaryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidLimitException" => {
return RusotoError::Service(
GetAggregateConfigRuleComplianceSummaryError::InvalidLimit(err.msg),
)
}
"InvalidNextTokenException" => {
return RusotoError::Service(
GetAggregateConfigRuleComplianceSummaryError::InvalidNextToken(err.msg),
)
}
"NoSuchConfigurationAggregatorException" => {
return RusotoError::Service(
GetAggregateConfigRuleComplianceSummaryError::NoSuchConfigurationAggregator(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetAggregateConfigRuleComplianceSummaryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetAggregateConfigRuleComplianceSummaryError::InvalidLimit(ref cause) => {
write!(f, "{}", cause)
}
GetAggregateConfigRuleComplianceSummaryError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
GetAggregateConfigRuleComplianceSummaryError::NoSuchConfigurationAggregator(
ref cause,
) => write!(f, "{}", cause),
}
}
}
impl Error for GetAggregateConfigRuleComplianceSummaryError {}
#[derive(Debug, PartialEq)]
pub enum GetAggregateDiscoveredResourceCountsError {
InvalidLimit(String),
InvalidNextToken(String),
NoSuchConfigurationAggregator(String),
}
impl GetAggregateDiscoveredResourceCountsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetAggregateDiscoveredResourceCountsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidLimitException" => {
return RusotoError::Service(
GetAggregateDiscoveredResourceCountsError::InvalidLimit(err.msg),
)
}
"InvalidNextTokenException" => {
return RusotoError::Service(
GetAggregateDiscoveredResourceCountsError::InvalidNextToken(err.msg),
)
}
"NoSuchConfigurationAggregatorException" => {
return RusotoError::Service(
GetAggregateDiscoveredResourceCountsError::NoSuchConfigurationAggregator(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetAggregateDiscoveredResourceCountsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetAggregateDiscoveredResourceCountsError::InvalidLimit(ref cause) => {
write!(f, "{}", cause)
}
GetAggregateDiscoveredResourceCountsError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
GetAggregateDiscoveredResourceCountsError::NoSuchConfigurationAggregator(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetAggregateDiscoveredResourceCountsError {}
#[derive(Debug, PartialEq)]
pub enum GetAggregateResourceConfigError {
NoSuchConfigurationAggregator(String),
OversizedConfigurationItem(String),
ResourceNotDiscovered(String),
}
impl GetAggregateResourceConfigError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetAggregateResourceConfigError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"NoSuchConfigurationAggregatorException" => {
return RusotoError::Service(
GetAggregateResourceConfigError::NoSuchConfigurationAggregator(err.msg),
)
}
"OversizedConfigurationItemException" => {
return RusotoError::Service(
GetAggregateResourceConfigError::OversizedConfigurationItem(err.msg),
)
}
"ResourceNotDiscoveredException" => {
return RusotoError::Service(
GetAggregateResourceConfigError::ResourceNotDiscovered(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetAggregateResourceConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetAggregateResourceConfigError::NoSuchConfigurationAggregator(ref cause) => {
write!(f, "{}", cause)
}
GetAggregateResourceConfigError::OversizedConfigurationItem(ref cause) => {
write!(f, "{}", cause)
}
GetAggregateResourceConfigError::ResourceNotDiscovered(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetAggregateResourceConfigError {}
#[derive(Debug, PartialEq)]
pub enum GetComplianceDetailsByConfigRuleError {
InvalidNextToken(String),
InvalidParameterValue(String),
NoSuchConfigRule(String),
}
impl GetComplianceDetailsByConfigRuleError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetComplianceDetailsByConfigRuleError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidNextTokenException" => {
return RusotoError::Service(
GetComplianceDetailsByConfigRuleError::InvalidNextToken(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
GetComplianceDetailsByConfigRuleError::InvalidParameterValue(err.msg),
)
}
"NoSuchConfigRuleException" => {
return RusotoError::Service(
GetComplianceDetailsByConfigRuleError::NoSuchConfigRule(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetComplianceDetailsByConfigRuleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetComplianceDetailsByConfigRuleError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
GetComplianceDetailsByConfigRuleError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
GetComplianceDetailsByConfigRuleError::NoSuchConfigRule(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetComplianceDetailsByConfigRuleError {}
#[derive(Debug, PartialEq)]
pub enum GetComplianceDetailsByResourceError {
InvalidParameterValue(String),
}
impl GetComplianceDetailsByResourceError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetComplianceDetailsByResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
GetComplianceDetailsByResourceError::InvalidParameterValue(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetComplianceDetailsByResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetComplianceDetailsByResourceError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetComplianceDetailsByResourceError {}
#[derive(Debug, PartialEq)]
pub enum GetComplianceSummaryByConfigRuleError {}
impl GetComplianceSummaryByConfigRuleError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetComplianceSummaryByConfigRuleError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetComplianceSummaryByConfigRuleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {}
}
}
impl Error for GetComplianceSummaryByConfigRuleError {}
#[derive(Debug, PartialEq)]
pub enum GetComplianceSummaryByResourceTypeError {
InvalidParameterValue(String),
}
impl GetComplianceSummaryByResourceTypeError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetComplianceSummaryByResourceTypeError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
GetComplianceSummaryByResourceTypeError::InvalidParameterValue(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetComplianceSummaryByResourceTypeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetComplianceSummaryByResourceTypeError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetComplianceSummaryByResourceTypeError {}
#[derive(Debug, PartialEq)]
pub enum GetConformancePackComplianceDetailsError {
InvalidLimit(String),
InvalidNextToken(String),
InvalidParameterValue(String),
NoSuchConfigRuleInConformancePack(String),
NoSuchConformancePack(String),
}
impl GetConformancePackComplianceDetailsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetConformancePackComplianceDetailsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidLimitException" => {
return RusotoError::Service(
GetConformancePackComplianceDetailsError::InvalidLimit(err.msg),
)
}
"InvalidNextTokenException" => {
return RusotoError::Service(
GetConformancePackComplianceDetailsError::InvalidNextToken(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
GetConformancePackComplianceDetailsError::InvalidParameterValue(err.msg),
)
}
"NoSuchConfigRuleInConformancePackException" => {
return RusotoError::Service(
GetConformancePackComplianceDetailsError::NoSuchConfigRuleInConformancePack(
err.msg,
),
)
}
"NoSuchConformancePackException" => {
return RusotoError::Service(
GetConformancePackComplianceDetailsError::NoSuchConformancePack(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetConformancePackComplianceDetailsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetConformancePackComplianceDetailsError::InvalidLimit(ref cause) => {
write!(f, "{}", cause)
}
GetConformancePackComplianceDetailsError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
GetConformancePackComplianceDetailsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
GetConformancePackComplianceDetailsError::NoSuchConfigRuleInConformancePack(
ref cause,
) => write!(f, "{}", cause),
GetConformancePackComplianceDetailsError::NoSuchConformancePack(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetConformancePackComplianceDetailsError {}
#[derive(Debug, PartialEq)]
pub enum GetConformancePackComplianceSummaryError {
InvalidLimit(String),
InvalidNextToken(String),
NoSuchConformancePack(String),
}
impl GetConformancePackComplianceSummaryError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetConformancePackComplianceSummaryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidLimitException" => {
return RusotoError::Service(
GetConformancePackComplianceSummaryError::InvalidLimit(err.msg),
)
}
"InvalidNextTokenException" => {
return RusotoError::Service(
GetConformancePackComplianceSummaryError::InvalidNextToken(err.msg),
)
}
"NoSuchConformancePackException" => {
return RusotoError::Service(
GetConformancePackComplianceSummaryError::NoSuchConformancePack(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetConformancePackComplianceSummaryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetConformancePackComplianceSummaryError::InvalidLimit(ref cause) => {
write!(f, "{}", cause)
}
GetConformancePackComplianceSummaryError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
GetConformancePackComplianceSummaryError::NoSuchConformancePack(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetConformancePackComplianceSummaryError {}
#[derive(Debug, PartialEq)]
pub enum GetDiscoveredResourceCountsError {
InvalidLimit(String),
InvalidNextToken(String),
}
impl GetDiscoveredResourceCountsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetDiscoveredResourceCountsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidLimitException" => {
return RusotoError::Service(GetDiscoveredResourceCountsError::InvalidLimit(
err.msg,
))
}
"InvalidNextTokenException" => {
return RusotoError::Service(
GetDiscoveredResourceCountsError::InvalidNextToken(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDiscoveredResourceCountsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDiscoveredResourceCountsError::InvalidLimit(ref cause) => write!(f, "{}", cause),
GetDiscoveredResourceCountsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDiscoveredResourceCountsError {}
#[derive(Debug, PartialEq)]
pub enum GetOrganizationConfigRuleDetailedStatusError {
InvalidLimit(String),
InvalidNextToken(String),
NoSuchOrganizationConfigRule(String),
OrganizationAccessDenied(String),
}
impl GetOrganizationConfigRuleDetailedStatusError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetOrganizationConfigRuleDetailedStatusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidLimitException" => {
return RusotoError::Service(
GetOrganizationConfigRuleDetailedStatusError::InvalidLimit(err.msg),
)
}
"InvalidNextTokenException" => {
return RusotoError::Service(
GetOrganizationConfigRuleDetailedStatusError::InvalidNextToken(err.msg),
)
}
"NoSuchOrganizationConfigRuleException" => {
return RusotoError::Service(
GetOrganizationConfigRuleDetailedStatusError::NoSuchOrganizationConfigRule(
err.msg,
),
)
}
"OrganizationAccessDeniedException" => {
return RusotoError::Service(
GetOrganizationConfigRuleDetailedStatusError::OrganizationAccessDenied(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetOrganizationConfigRuleDetailedStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetOrganizationConfigRuleDetailedStatusError::InvalidLimit(ref cause) => {
write!(f, "{}", cause)
}
GetOrganizationConfigRuleDetailedStatusError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
GetOrganizationConfigRuleDetailedStatusError::NoSuchOrganizationConfigRule(
ref cause,
) => write!(f, "{}", cause),
GetOrganizationConfigRuleDetailedStatusError::OrganizationAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetOrganizationConfigRuleDetailedStatusError {}
#[derive(Debug, PartialEq)]
pub enum GetOrganizationConformancePackDetailedStatusError {
InvalidLimit(String),
InvalidNextToken(String),
NoSuchOrganizationConformancePack(String),
OrganizationAccessDenied(String),
}
impl GetOrganizationConformancePackDetailedStatusError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetOrganizationConformancePackDetailedStatusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidLimitException" => return RusotoError::Service(GetOrganizationConformancePackDetailedStatusError::InvalidLimit(err.msg)),
"InvalidNextTokenException" => return RusotoError::Service(GetOrganizationConformancePackDetailedStatusError::InvalidNextToken(err.msg)),
"NoSuchOrganizationConformancePackException" => return RusotoError::Service(GetOrganizationConformancePackDetailedStatusError::NoSuchOrganizationConformancePack(err.msg)),
"OrganizationAccessDeniedException" => return RusotoError::Service(GetOrganizationConformancePackDetailedStatusError::OrganizationAccessDenied(err.msg)),
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetOrganizationConformancePackDetailedStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetOrganizationConformancePackDetailedStatusError::InvalidLimit(ref cause) => write!(f, "{}", cause),
GetOrganizationConformancePackDetailedStatusError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
GetOrganizationConformancePackDetailedStatusError::NoSuchOrganizationConformancePack(ref cause) => write!(f, "{}", cause),
GetOrganizationConformancePackDetailedStatusError::OrganizationAccessDenied(ref cause) => write!(f, "{}", cause)
}
}
}
impl Error for GetOrganizationConformancePackDetailedStatusError {}
#[derive(Debug, PartialEq)]
pub enum GetResourceConfigHistoryError {
InvalidLimit(String),
InvalidNextToken(String),
InvalidTimeRange(String),
NoAvailableConfigurationRecorder(String),
ResourceNotDiscovered(String),
}
impl GetResourceConfigHistoryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetResourceConfigHistoryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidLimitException" => {
return RusotoError::Service(GetResourceConfigHistoryError::InvalidLimit(
err.msg,
))
}
"InvalidNextTokenException" => {
return RusotoError::Service(GetResourceConfigHistoryError::InvalidNextToken(
err.msg,
))
}
"InvalidTimeRangeException" => {
return RusotoError::Service(GetResourceConfigHistoryError::InvalidTimeRange(
err.msg,
))
}
"NoAvailableConfigurationRecorderException" => {
return RusotoError::Service(
GetResourceConfigHistoryError::NoAvailableConfigurationRecorder(err.msg),
)
}
"ResourceNotDiscoveredException" => {
return RusotoError::Service(
GetResourceConfigHistoryError::ResourceNotDiscovered(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetResourceConfigHistoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetResourceConfigHistoryError::InvalidLimit(ref cause) => write!(f, "{}", cause),
GetResourceConfigHistoryError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
GetResourceConfigHistoryError::InvalidTimeRange(ref cause) => write!(f, "{}", cause),
GetResourceConfigHistoryError::NoAvailableConfigurationRecorder(ref cause) => {
write!(f, "{}", cause)
}
GetResourceConfigHistoryError::ResourceNotDiscovered(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetResourceConfigHistoryError {}
#[derive(Debug, PartialEq)]
pub enum ListAggregateDiscoveredResourcesError {
InvalidLimit(String),
InvalidNextToken(String),
NoSuchConfigurationAggregator(String),
}
impl ListAggregateDiscoveredResourcesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListAggregateDiscoveredResourcesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidLimitException" => {
return RusotoError::Service(
ListAggregateDiscoveredResourcesError::InvalidLimit(err.msg),
)
}
"InvalidNextTokenException" => {
return RusotoError::Service(
ListAggregateDiscoveredResourcesError::InvalidNextToken(err.msg),
)
}
"NoSuchConfigurationAggregatorException" => {
return RusotoError::Service(
ListAggregateDiscoveredResourcesError::NoSuchConfigurationAggregator(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListAggregateDiscoveredResourcesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListAggregateDiscoveredResourcesError::InvalidLimit(ref cause) => {
write!(f, "{}", cause)
}
ListAggregateDiscoveredResourcesError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
ListAggregateDiscoveredResourcesError::NoSuchConfigurationAggregator(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListAggregateDiscoveredResourcesError {}
#[derive(Debug, PartialEq)]
pub enum ListDiscoveredResourcesError {
InvalidLimit(String),
InvalidNextToken(String),
NoAvailableConfigurationRecorder(String),
}
impl ListDiscoveredResourcesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDiscoveredResourcesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidLimitException" => {
return RusotoError::Service(ListDiscoveredResourcesError::InvalidLimit(
err.msg,
))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListDiscoveredResourcesError::InvalidNextToken(
err.msg,
))
}
"NoAvailableConfigurationRecorderException" => {
return RusotoError::Service(
ListDiscoveredResourcesError::NoAvailableConfigurationRecorder(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDiscoveredResourcesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDiscoveredResourcesError::InvalidLimit(ref cause) => write!(f, "{}", cause),
ListDiscoveredResourcesError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListDiscoveredResourcesError::NoAvailableConfigurationRecorder(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListDiscoveredResourcesError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
InvalidLimit(String),
InvalidNextToken(String),
ResourceNotFound(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidLimitException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidLimit(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidNextToken(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListTagsForResourceError::ResourceNotFound(
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::InvalidLimit(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum PutAggregationAuthorizationError {
InvalidParameterValue(String),
}
impl PutAggregationAuthorizationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PutAggregationAuthorizationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
PutAggregationAuthorizationError::InvalidParameterValue(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutAggregationAuthorizationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutAggregationAuthorizationError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PutAggregationAuthorizationError {}
#[derive(Debug, PartialEq)]
pub enum PutConfigRuleError {
InsufficientPermissions(String),
InvalidParameterValue(String),
MaxNumberOfConfigRulesExceeded(String),
NoAvailableConfigurationRecorder(String),
ResourceInUse(String),
}
impl PutConfigRuleError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutConfigRuleError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InsufficientPermissionsException" => {
return RusotoError::Service(PutConfigRuleError::InsufficientPermissions(
err.msg,
))
}
"InvalidParameterValueException" => {
return RusotoError::Service(PutConfigRuleError::InvalidParameterValue(err.msg))
}
"MaxNumberOfConfigRulesExceededException" => {
return RusotoError::Service(
PutConfigRuleError::MaxNumberOfConfigRulesExceeded(err.msg),
)
}
"NoAvailableConfigurationRecorderException" => {
return RusotoError::Service(
PutConfigRuleError::NoAvailableConfigurationRecorder(err.msg),
)
}
"ResourceInUseException" => {
return RusotoError::Service(PutConfigRuleError::ResourceInUse(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutConfigRuleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutConfigRuleError::InsufficientPermissions(ref cause) => write!(f, "{}", cause),
PutConfigRuleError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
PutConfigRuleError::MaxNumberOfConfigRulesExceeded(ref cause) => write!(f, "{}", cause),
PutConfigRuleError::NoAvailableConfigurationRecorder(ref cause) => {
write!(f, "{}", cause)
}
PutConfigRuleError::ResourceInUse(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutConfigRuleError {}
#[derive(Debug, PartialEq)]
pub enum PutConfigurationAggregatorError {
InvalidParameterValue(String),
InvalidRole(String),
LimitExceeded(String),
NoAvailableOrganization(String),
OrganizationAccessDenied(String),
OrganizationAllFeaturesNotEnabled(String),
}
impl PutConfigurationAggregatorError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PutConfigurationAggregatorError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
PutConfigurationAggregatorError::InvalidParameterValue(err.msg),
)
}
"InvalidRoleException" => {
return RusotoError::Service(PutConfigurationAggregatorError::InvalidRole(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(PutConfigurationAggregatorError::LimitExceeded(
err.msg,
))
}
"NoAvailableOrganizationException" => {
return RusotoError::Service(
PutConfigurationAggregatorError::NoAvailableOrganization(err.msg),
)
}
"OrganizationAccessDeniedException" => {
return RusotoError::Service(
PutConfigurationAggregatorError::OrganizationAccessDenied(err.msg),
)
}
"OrganizationAllFeaturesNotEnabledException" => {
return RusotoError::Service(
PutConfigurationAggregatorError::OrganizationAllFeaturesNotEnabled(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutConfigurationAggregatorError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutConfigurationAggregatorError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
PutConfigurationAggregatorError::InvalidRole(ref cause) => write!(f, "{}", cause),
PutConfigurationAggregatorError::LimitExceeded(ref cause) => write!(f, "{}", cause),
PutConfigurationAggregatorError::NoAvailableOrganization(ref cause) => {
write!(f, "{}", cause)
}
PutConfigurationAggregatorError::OrganizationAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
PutConfigurationAggregatorError::OrganizationAllFeaturesNotEnabled(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PutConfigurationAggregatorError {}
#[derive(Debug, PartialEq)]
pub enum PutConfigurationRecorderError {
InvalidConfigurationRecorderName(String),
InvalidRecordingGroup(String),
InvalidRole(String),
MaxNumberOfConfigurationRecordersExceeded(String),
}
impl PutConfigurationRecorderError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutConfigurationRecorderError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidConfigurationRecorderNameException" => {
return RusotoError::Service(
PutConfigurationRecorderError::InvalidConfigurationRecorderName(err.msg),
)
}
"InvalidRecordingGroupException" => {
return RusotoError::Service(
PutConfigurationRecorderError::InvalidRecordingGroup(err.msg),
)
}
"InvalidRoleException" => {
return RusotoError::Service(PutConfigurationRecorderError::InvalidRole(
err.msg,
))
}
"MaxNumberOfConfigurationRecordersExceededException" => {
return RusotoError::Service(
PutConfigurationRecorderError::MaxNumberOfConfigurationRecordersExceeded(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutConfigurationRecorderError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutConfigurationRecorderError::InvalidConfigurationRecorderName(ref cause) => {
write!(f, "{}", cause)
}
PutConfigurationRecorderError::InvalidRecordingGroup(ref cause) => {
write!(f, "{}", cause)
}
PutConfigurationRecorderError::InvalidRole(ref cause) => write!(f, "{}", cause),
PutConfigurationRecorderError::MaxNumberOfConfigurationRecordersExceeded(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PutConfigurationRecorderError {}
#[derive(Debug, PartialEq)]
pub enum PutConformancePackError {
ConformancePackTemplateValidation(String),
InsufficientPermissions(String),
InvalidParameterValue(String),
MaxNumberOfConformancePacksExceeded(String),
ResourceInUse(String),
}
impl PutConformancePackError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutConformancePackError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ConformancePackTemplateValidationException" => {
return RusotoError::Service(
PutConformancePackError::ConformancePackTemplateValidation(err.msg),
)
}
"InsufficientPermissionsException" => {
return RusotoError::Service(PutConformancePackError::InsufficientPermissions(
err.msg,
))
}
"InvalidParameterValueException" => {
return RusotoError::Service(PutConformancePackError::InvalidParameterValue(
err.msg,
))
}
"MaxNumberOfConformancePacksExceededException" => {
return RusotoError::Service(
PutConformancePackError::MaxNumberOfConformancePacksExceeded(err.msg),
)
}
"ResourceInUseException" => {
return RusotoError::Service(PutConformancePackError::ResourceInUse(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutConformancePackError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutConformancePackError::ConformancePackTemplateValidation(ref cause) => {
write!(f, "{}", cause)
}
PutConformancePackError::InsufficientPermissions(ref cause) => write!(f, "{}", cause),
PutConformancePackError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
PutConformancePackError::MaxNumberOfConformancePacksExceeded(ref cause) => {
write!(f, "{}", cause)
}
PutConformancePackError::ResourceInUse(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutConformancePackError {}
#[derive(Debug, PartialEq)]
pub enum PutDeliveryChannelError {
InsufficientDeliveryPolicy(String),
InvalidDeliveryChannelName(String),
InvalidS3KeyPrefix(String),
InvalidSNSTopicARN(String),
MaxNumberOfDeliveryChannelsExceeded(String),
NoAvailableConfigurationRecorder(String),
NoSuchBucket(String),
}
impl PutDeliveryChannelError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutDeliveryChannelError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InsufficientDeliveryPolicyException" => {
return RusotoError::Service(
PutDeliveryChannelError::InsufficientDeliveryPolicy(err.msg),
)
}
"InvalidDeliveryChannelNameException" => {
return RusotoError::Service(
PutDeliveryChannelError::InvalidDeliveryChannelName(err.msg),
)
}
"InvalidS3KeyPrefixException" => {
return RusotoError::Service(PutDeliveryChannelError::InvalidS3KeyPrefix(
err.msg,
))
}
"InvalidSNSTopicARNException" => {
return RusotoError::Service(PutDeliveryChannelError::InvalidSNSTopicARN(
err.msg,
))
}
"MaxNumberOfDeliveryChannelsExceededException" => {
return RusotoError::Service(
PutDeliveryChannelError::MaxNumberOfDeliveryChannelsExceeded(err.msg),
)
}
"NoAvailableConfigurationRecorderException" => {
return RusotoError::Service(
PutDeliveryChannelError::NoAvailableConfigurationRecorder(err.msg),
)
}
"NoSuchBucketException" => {
return RusotoError::Service(PutDeliveryChannelError::NoSuchBucket(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutDeliveryChannelError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutDeliveryChannelError::InsufficientDeliveryPolicy(ref cause) => {
write!(f, "{}", cause)
}
PutDeliveryChannelError::InvalidDeliveryChannelName(ref cause) => {
write!(f, "{}", cause)
}
PutDeliveryChannelError::InvalidS3KeyPrefix(ref cause) => write!(f, "{}", cause),
PutDeliveryChannelError::InvalidSNSTopicARN(ref cause) => write!(f, "{}", cause),
PutDeliveryChannelError::MaxNumberOfDeliveryChannelsExceeded(ref cause) => {
write!(f, "{}", cause)
}
PutDeliveryChannelError::NoAvailableConfigurationRecorder(ref cause) => {
write!(f, "{}", cause)
}
PutDeliveryChannelError::NoSuchBucket(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutDeliveryChannelError {}
#[derive(Debug, PartialEq)]
pub enum PutEvaluationsError {
InvalidParameterValue(String),
InvalidResultToken(String),
NoSuchConfigRule(String),
}
impl PutEvaluationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutEvaluationsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(PutEvaluationsError::InvalidParameterValue(
err.msg,
))
}
"InvalidResultTokenException" => {
return RusotoError::Service(PutEvaluationsError::InvalidResultToken(err.msg))
}
"NoSuchConfigRuleException" => {
return RusotoError::Service(PutEvaluationsError::NoSuchConfigRule(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutEvaluationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutEvaluationsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
PutEvaluationsError::InvalidResultToken(ref cause) => write!(f, "{}", cause),
PutEvaluationsError::NoSuchConfigRule(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutEvaluationsError {}
#[derive(Debug, PartialEq)]
pub enum PutOrganizationConfigRuleError {
InsufficientPermissions(String),
InvalidParameterValue(String),
MaxNumberOfOrganizationConfigRulesExceeded(String),
NoAvailableOrganization(String),
OrganizationAccessDenied(String),
OrganizationAllFeaturesNotEnabled(String),
ResourceInUse(String),
}
impl PutOrganizationConfigRuleError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutOrganizationConfigRuleError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InsufficientPermissionsException" => {
return RusotoError::Service(
PutOrganizationConfigRuleError::InsufficientPermissions(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
PutOrganizationConfigRuleError::InvalidParameterValue(err.msg),
)
}
"MaxNumberOfOrganizationConfigRulesExceededException" => {
return RusotoError::Service(
PutOrganizationConfigRuleError::MaxNumberOfOrganizationConfigRulesExceeded(
err.msg,
),
)
}
"NoAvailableOrganizationException" => {
return RusotoError::Service(
PutOrganizationConfigRuleError::NoAvailableOrganization(err.msg),
)
}
"OrganizationAccessDeniedException" => {
return RusotoError::Service(
PutOrganizationConfigRuleError::OrganizationAccessDenied(err.msg),
)
}
"OrganizationAllFeaturesNotEnabledException" => {
return RusotoError::Service(
PutOrganizationConfigRuleError::OrganizationAllFeaturesNotEnabled(err.msg),
)
}
"ResourceInUseException" => {
return RusotoError::Service(PutOrganizationConfigRuleError::ResourceInUse(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutOrganizationConfigRuleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutOrganizationConfigRuleError::InsufficientPermissions(ref cause) => {
write!(f, "{}", cause)
}
PutOrganizationConfigRuleError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
PutOrganizationConfigRuleError::MaxNumberOfOrganizationConfigRulesExceeded(
ref cause,
) => write!(f, "{}", cause),
PutOrganizationConfigRuleError::NoAvailableOrganization(ref cause) => {
write!(f, "{}", cause)
}
PutOrganizationConfigRuleError::OrganizationAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
PutOrganizationConfigRuleError::OrganizationAllFeaturesNotEnabled(ref cause) => {
write!(f, "{}", cause)
}
PutOrganizationConfigRuleError::ResourceInUse(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutOrganizationConfigRuleError {}
#[derive(Debug, PartialEq)]
pub enum PutOrganizationConformancePackError {
InsufficientPermissions(String),
MaxNumberOfOrganizationConformancePacksExceeded(String),
NoAvailableOrganization(String),
OrganizationAccessDenied(String),
OrganizationAllFeaturesNotEnabled(String),
OrganizationConformancePackTemplateValidation(String),
ResourceInUse(String),
}
impl PutOrganizationConformancePackError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PutOrganizationConformancePackError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InsufficientPermissionsException" => return RusotoError::Service(PutOrganizationConformancePackError::InsufficientPermissions(err.msg)),
"MaxNumberOfOrganizationConformancePacksExceededException" => return RusotoError::Service(PutOrganizationConformancePackError::MaxNumberOfOrganizationConformancePacksExceeded(err.msg)),
"NoAvailableOrganizationException" => return RusotoError::Service(PutOrganizationConformancePackError::NoAvailableOrganization(err.msg)),
"OrganizationAccessDeniedException" => return RusotoError::Service(PutOrganizationConformancePackError::OrganizationAccessDenied(err.msg)),
"OrganizationAllFeaturesNotEnabledException" => return RusotoError::Service(PutOrganizationConformancePackError::OrganizationAllFeaturesNotEnabled(err.msg)),
"OrganizationConformancePackTemplateValidationException" => return RusotoError::Service(PutOrganizationConformancePackError::OrganizationConformancePackTemplateValidation(err.msg)),
"ResourceInUseException" => return RusotoError::Service(PutOrganizationConformancePackError::ResourceInUse(err.msg)),
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutOrganizationConformancePackError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutOrganizationConformancePackError::InsufficientPermissions(ref cause) => write!(f, "{}", cause),
PutOrganizationConformancePackError::MaxNumberOfOrganizationConformancePacksExceeded(ref cause) => write!(f, "{}", cause),
PutOrganizationConformancePackError::NoAvailableOrganization(ref cause) => write!(f, "{}", cause),
PutOrganizationConformancePackError::OrganizationAccessDenied(ref cause) => write!(f, "{}", cause),
PutOrganizationConformancePackError::OrganizationAllFeaturesNotEnabled(ref cause) => write!(f, "{}", cause),
PutOrganizationConformancePackError::OrganizationConformancePackTemplateValidation(ref cause) => write!(f, "{}", cause),
PutOrganizationConformancePackError::ResourceInUse(ref cause) => write!(f, "{}", cause)
}
}
}
impl Error for PutOrganizationConformancePackError {}
#[derive(Debug, PartialEq)]
pub enum PutRemediationConfigurationsError {
InsufficientPermissions(String),
InvalidParameterValue(String),
}
impl PutRemediationConfigurationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PutRemediationConfigurationsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InsufficientPermissionsException" => {
return RusotoError::Service(
PutRemediationConfigurationsError::InsufficientPermissions(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
PutRemediationConfigurationsError::InvalidParameterValue(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutRemediationConfigurationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutRemediationConfigurationsError::InsufficientPermissions(ref cause) => {
write!(f, "{}", cause)
}
PutRemediationConfigurationsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PutRemediationConfigurationsError {}
#[derive(Debug, PartialEq)]
pub enum PutRemediationExceptionsError {
InvalidParameterValue(String),
}
impl PutRemediationExceptionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutRemediationExceptionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
PutRemediationExceptionsError::InvalidParameterValue(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutRemediationExceptionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutRemediationExceptionsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PutRemediationExceptionsError {}
#[derive(Debug, PartialEq)]
pub enum PutResourceConfigError {
InsufficientPermissions(String),
MaxActiveResourcesExceeded(String),
NoRunningConfigurationRecorder(String),
}
impl PutResourceConfigError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutResourceConfigError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InsufficientPermissionsException" => {
return RusotoError::Service(PutResourceConfigError::InsufficientPermissions(
err.msg,
))
}
"MaxActiveResourcesExceededException" => {
return RusotoError::Service(
PutResourceConfigError::MaxActiveResourcesExceeded(err.msg),
)
}
"NoRunningConfigurationRecorderException" => {
return RusotoError::Service(
PutResourceConfigError::NoRunningConfigurationRecorder(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutResourceConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutResourceConfigError::InsufficientPermissions(ref cause) => write!(f, "{}", cause),
PutResourceConfigError::MaxActiveResourcesExceeded(ref cause) => write!(f, "{}", cause),
PutResourceConfigError::NoRunningConfigurationRecorder(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PutResourceConfigError {}
#[derive(Debug, PartialEq)]
pub enum PutRetentionConfigurationError {
InvalidParameterValue(String),
MaxNumberOfRetentionConfigurationsExceeded(String),
}
impl PutRetentionConfigurationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutRetentionConfigurationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
PutRetentionConfigurationError::InvalidParameterValue(err.msg),
)
}
"MaxNumberOfRetentionConfigurationsExceededException" => {
return RusotoError::Service(
PutRetentionConfigurationError::MaxNumberOfRetentionConfigurationsExceeded(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutRetentionConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutRetentionConfigurationError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
PutRetentionConfigurationError::MaxNumberOfRetentionConfigurationsExceeded(
ref cause,
) => write!(f, "{}", cause),
}
}
}
impl Error for PutRetentionConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum SelectAggregateResourceConfigError {
InvalidExpression(String),
InvalidLimit(String),
InvalidNextToken(String),
NoSuchConfigurationAggregator(String),
}
impl SelectAggregateResourceConfigError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<SelectAggregateResourceConfigError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidExpressionException" => {
return RusotoError::Service(
SelectAggregateResourceConfigError::InvalidExpression(err.msg),
)
}
"InvalidLimitException" => {
return RusotoError::Service(SelectAggregateResourceConfigError::InvalidLimit(
err.msg,
))
}
"InvalidNextTokenException" => {
return RusotoError::Service(
SelectAggregateResourceConfigError::InvalidNextToken(err.msg),
)
}
"NoSuchConfigurationAggregatorException" => {
return RusotoError::Service(
SelectAggregateResourceConfigError::NoSuchConfigurationAggregator(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SelectAggregateResourceConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SelectAggregateResourceConfigError::InvalidExpression(ref cause) => {
write!(f, "{}", cause)
}
SelectAggregateResourceConfigError::InvalidLimit(ref cause) => write!(f, "{}", cause),
SelectAggregateResourceConfigError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
SelectAggregateResourceConfigError::NoSuchConfigurationAggregator(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for SelectAggregateResourceConfigError {}
#[derive(Debug, PartialEq)]
pub enum SelectResourceConfigError {
InvalidExpression(String),
InvalidLimit(String),
InvalidNextToken(String),
}
impl SelectResourceConfigError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SelectResourceConfigError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidExpressionException" => {
return RusotoError::Service(SelectResourceConfigError::InvalidExpression(
err.msg,
))
}
"InvalidLimitException" => {
return RusotoError::Service(SelectResourceConfigError::InvalidLimit(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(SelectResourceConfigError::InvalidNextToken(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SelectResourceConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SelectResourceConfigError::InvalidExpression(ref cause) => write!(f, "{}", cause),
SelectResourceConfigError::InvalidLimit(ref cause) => write!(f, "{}", cause),
SelectResourceConfigError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SelectResourceConfigError {}
#[derive(Debug, PartialEq)]
pub enum StartConfigRulesEvaluationError {
InvalidParameterValue(String),
LimitExceeded(String),
NoSuchConfigRule(String),
ResourceInUse(String),
}
impl StartConfigRulesEvaluationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<StartConfigRulesEvaluationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
StartConfigRulesEvaluationError::InvalidParameterValue(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(StartConfigRulesEvaluationError::LimitExceeded(
err.msg,
))
}
"NoSuchConfigRuleException" => {
return RusotoError::Service(StartConfigRulesEvaluationError::NoSuchConfigRule(
err.msg,
))
}
"ResourceInUseException" => {
return RusotoError::Service(StartConfigRulesEvaluationError::ResourceInUse(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartConfigRulesEvaluationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartConfigRulesEvaluationError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
StartConfigRulesEvaluationError::LimitExceeded(ref cause) => write!(f, "{}", cause),
StartConfigRulesEvaluationError::NoSuchConfigRule(ref cause) => write!(f, "{}", cause),
StartConfigRulesEvaluationError::ResourceInUse(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartConfigRulesEvaluationError {}
#[derive(Debug, PartialEq)]
pub enum StartConfigurationRecorderError {
NoAvailableDeliveryChannel(String),
NoSuchConfigurationRecorder(String),
}
impl StartConfigurationRecorderError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<StartConfigurationRecorderError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"NoAvailableDeliveryChannelException" => {
return RusotoError::Service(
StartConfigurationRecorderError::NoAvailableDeliveryChannel(err.msg),
)
}
"NoSuchConfigurationRecorderException" => {
return RusotoError::Service(
StartConfigurationRecorderError::NoSuchConfigurationRecorder(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartConfigurationRecorderError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartConfigurationRecorderError::NoAvailableDeliveryChannel(ref cause) => {
write!(f, "{}", cause)
}
StartConfigurationRecorderError::NoSuchConfigurationRecorder(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for StartConfigurationRecorderError {}
#[derive(Debug, PartialEq)]
pub enum StartRemediationExecutionError {
InsufficientPermissions(String),
InvalidParameterValue(String),
NoSuchRemediationConfiguration(String),
}
impl StartRemediationExecutionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartRemediationExecutionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InsufficientPermissionsException" => {
return RusotoError::Service(
StartRemediationExecutionError::InsufficientPermissions(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
StartRemediationExecutionError::InvalidParameterValue(err.msg),
)
}
"NoSuchRemediationConfigurationException" => {
return RusotoError::Service(
StartRemediationExecutionError::NoSuchRemediationConfiguration(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartRemediationExecutionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartRemediationExecutionError::InsufficientPermissions(ref cause) => {
write!(f, "{}", cause)
}
StartRemediationExecutionError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
StartRemediationExecutionError::NoSuchRemediationConfiguration(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for StartRemediationExecutionError {}
#[derive(Debug, PartialEq)]
pub enum StopConfigurationRecorderError {
NoSuchConfigurationRecorder(String),
}
impl StopConfigurationRecorderError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopConfigurationRecorderError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"NoSuchConfigurationRecorderException" => {
return RusotoError::Service(
StopConfigurationRecorderError::NoSuchConfigurationRecorder(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StopConfigurationRecorderError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StopConfigurationRecorderError::NoSuchConfigurationRecorder(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for StopConfigurationRecorderError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
ResourceNotFound(String),
TooManyTags(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ResourceNotFoundException" => {
return RusotoError::Service(TagResourceError::ResourceNotFound(err.msg))
}
"TooManyTagsException" => {
return RusotoError::Service(TagResourceError::TooManyTags(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::ResourceNotFound(ref cause) => write!(f, "{}", cause),
TagResourceError::TooManyTags(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
ResourceNotFound(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ResourceNotFoundException" => {
return RusotoError::Service(UntagResourceError::ResourceNotFound(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::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[async_trait]
pub trait ConfigService {
async fn batch_get_aggregate_resource_config(
&self,
input: BatchGetAggregateResourceConfigRequest,
) -> Result<
BatchGetAggregateResourceConfigResponse,
RusotoError<BatchGetAggregateResourceConfigError>,
>;
async fn batch_get_resource_config(
&self,
input: BatchGetResourceConfigRequest,
) -> Result<BatchGetResourceConfigResponse, RusotoError<BatchGetResourceConfigError>>;
async fn delete_aggregation_authorization(
&self,
input: DeleteAggregationAuthorizationRequest,
) -> Result<(), RusotoError<DeleteAggregationAuthorizationError>>;
async fn delete_config_rule(
&self,
input: DeleteConfigRuleRequest,
) -> Result<(), RusotoError<DeleteConfigRuleError>>;
async fn delete_configuration_aggregator(
&self,
input: DeleteConfigurationAggregatorRequest,
) -> Result<(), RusotoError<DeleteConfigurationAggregatorError>>;
async fn delete_configuration_recorder(
&self,
input: DeleteConfigurationRecorderRequest,
) -> Result<(), RusotoError<DeleteConfigurationRecorderError>>;
async fn delete_conformance_pack(
&self,
input: DeleteConformancePackRequest,
) -> Result<(), RusotoError<DeleteConformancePackError>>;
async fn delete_delivery_channel(
&self,
input: DeleteDeliveryChannelRequest,
) -> Result<(), RusotoError<DeleteDeliveryChannelError>>;
async fn delete_evaluation_results(
&self,
input: DeleteEvaluationResultsRequest,
) -> Result<DeleteEvaluationResultsResponse, RusotoError<DeleteEvaluationResultsError>>;
async fn delete_organization_config_rule(
&self,
input: DeleteOrganizationConfigRuleRequest,
) -> Result<(), RusotoError<DeleteOrganizationConfigRuleError>>;
async fn delete_organization_conformance_pack(
&self,
input: DeleteOrganizationConformancePackRequest,
) -> Result<(), RusotoError<DeleteOrganizationConformancePackError>>;
async fn delete_pending_aggregation_request(
&self,
input: DeletePendingAggregationRequestRequest,
) -> Result<(), RusotoError<DeletePendingAggregationRequestError>>;
async fn delete_remediation_configuration(
&self,
input: DeleteRemediationConfigurationRequest,
) -> Result<
DeleteRemediationConfigurationResponse,
RusotoError<DeleteRemediationConfigurationError>,
>;
async fn delete_remediation_exceptions(
&self,
input: DeleteRemediationExceptionsRequest,
) -> Result<DeleteRemediationExceptionsResponse, RusotoError<DeleteRemediationExceptionsError>>;
async fn delete_resource_config(
&self,
input: DeleteResourceConfigRequest,
) -> Result<(), RusotoError<DeleteResourceConfigError>>;
async fn delete_retention_configuration(
&self,
input: DeleteRetentionConfigurationRequest,
) -> Result<(), RusotoError<DeleteRetentionConfigurationError>>;
async fn deliver_config_snapshot(
&self,
input: DeliverConfigSnapshotRequest,
) -> Result<DeliverConfigSnapshotResponse, RusotoError<DeliverConfigSnapshotError>>;
async fn describe_aggregate_compliance_by_config_rules(
&self,
input: DescribeAggregateComplianceByConfigRulesRequest,
) -> Result<
DescribeAggregateComplianceByConfigRulesResponse,
RusotoError<DescribeAggregateComplianceByConfigRulesError>,
>;
async fn describe_aggregation_authorizations(
&self,
input: DescribeAggregationAuthorizationsRequest,
) -> Result<
DescribeAggregationAuthorizationsResponse,
RusotoError<DescribeAggregationAuthorizationsError>,
>;
async fn describe_compliance_by_config_rule(
&self,
input: DescribeComplianceByConfigRuleRequest,
) -> Result<
DescribeComplianceByConfigRuleResponse,
RusotoError<DescribeComplianceByConfigRuleError>,
>;
async fn describe_compliance_by_resource(
&self,
input: DescribeComplianceByResourceRequest,
) -> Result<DescribeComplianceByResourceResponse, RusotoError<DescribeComplianceByResourceError>>;
async fn describe_config_rule_evaluation_status(
&self,
input: DescribeConfigRuleEvaluationStatusRequest,
) -> Result<
DescribeConfigRuleEvaluationStatusResponse,
RusotoError<DescribeConfigRuleEvaluationStatusError>,
>;
async fn describe_config_rules(
&self,
input: DescribeConfigRulesRequest,
) -> Result<DescribeConfigRulesResponse, RusotoError<DescribeConfigRulesError>>;
async fn describe_configuration_aggregator_sources_status(
&self,
input: DescribeConfigurationAggregatorSourcesStatusRequest,
) -> Result<
DescribeConfigurationAggregatorSourcesStatusResponse,
RusotoError<DescribeConfigurationAggregatorSourcesStatusError>,
>;
async fn describe_configuration_aggregators(
&self,
input: DescribeConfigurationAggregatorsRequest,
) -> Result<
DescribeConfigurationAggregatorsResponse,
RusotoError<DescribeConfigurationAggregatorsError>,
>;
async fn describe_configuration_recorder_status(
&self,
input: DescribeConfigurationRecorderStatusRequest,
) -> Result<
DescribeConfigurationRecorderStatusResponse,
RusotoError<DescribeConfigurationRecorderStatusError>,
>;
async fn describe_configuration_recorders(
&self,
input: DescribeConfigurationRecordersRequest,
) -> Result<
DescribeConfigurationRecordersResponse,
RusotoError<DescribeConfigurationRecordersError>,
>;
async fn describe_conformance_pack_compliance(
&self,
input: DescribeConformancePackComplianceRequest,
) -> Result<
DescribeConformancePackComplianceResponse,
RusotoError<DescribeConformancePackComplianceError>,
>;
async fn describe_conformance_pack_status(
&self,
input: DescribeConformancePackStatusRequest,
) -> Result<
DescribeConformancePackStatusResponse,
RusotoError<DescribeConformancePackStatusError>,
>;
async fn describe_conformance_packs(
&self,
input: DescribeConformancePacksRequest,
) -> Result<DescribeConformancePacksResponse, RusotoError<DescribeConformancePacksError>>;
async fn describe_delivery_channel_status(
&self,
input: DescribeDeliveryChannelStatusRequest,
) -> Result<
DescribeDeliveryChannelStatusResponse,
RusotoError<DescribeDeliveryChannelStatusError>,
>;
async fn describe_delivery_channels(
&self,
input: DescribeDeliveryChannelsRequest,
) -> Result<DescribeDeliveryChannelsResponse, RusotoError<DescribeDeliveryChannelsError>>;
async fn describe_organization_config_rule_statuses(
&self,
input: DescribeOrganizationConfigRuleStatusesRequest,
) -> Result<
DescribeOrganizationConfigRuleStatusesResponse,
RusotoError<DescribeOrganizationConfigRuleStatusesError>,
>;
async fn describe_organization_config_rules(
&self,
input: DescribeOrganizationConfigRulesRequest,
) -> Result<
DescribeOrganizationConfigRulesResponse,
RusotoError<DescribeOrganizationConfigRulesError>,
>;
async fn describe_organization_conformance_pack_statuses(
&self,
input: DescribeOrganizationConformancePackStatusesRequest,
) -> Result<
DescribeOrganizationConformancePackStatusesResponse,
RusotoError<DescribeOrganizationConformancePackStatusesError>,
>;
async fn describe_organization_conformance_packs(
&self,
input: DescribeOrganizationConformancePacksRequest,
) -> Result<
DescribeOrganizationConformancePacksResponse,
RusotoError<DescribeOrganizationConformancePacksError>,
>;
async fn describe_pending_aggregation_requests(
&self,
input: DescribePendingAggregationRequestsRequest,
) -> Result<
DescribePendingAggregationRequestsResponse,
RusotoError<DescribePendingAggregationRequestsError>,
>;
async fn describe_remediation_configurations(
&self,
input: DescribeRemediationConfigurationsRequest,
) -> Result<
DescribeRemediationConfigurationsResponse,
RusotoError<DescribeRemediationConfigurationsError>,
>;
async fn describe_remediation_exceptions(
&self,
input: DescribeRemediationExceptionsRequest,
) -> Result<
DescribeRemediationExceptionsResponse,
RusotoError<DescribeRemediationExceptionsError>,
>;
async fn describe_remediation_execution_status(
&self,
input: DescribeRemediationExecutionStatusRequest,
) -> Result<
DescribeRemediationExecutionStatusResponse,
RusotoError<DescribeRemediationExecutionStatusError>,
>;
async fn describe_retention_configurations(
&self,
input: DescribeRetentionConfigurationsRequest,
) -> Result<
DescribeRetentionConfigurationsResponse,
RusotoError<DescribeRetentionConfigurationsError>,
>;
async fn get_aggregate_compliance_details_by_config_rule(
&self,
input: GetAggregateComplianceDetailsByConfigRuleRequest,
) -> Result<
GetAggregateComplianceDetailsByConfigRuleResponse,
RusotoError<GetAggregateComplianceDetailsByConfigRuleError>,
>;
async fn get_aggregate_config_rule_compliance_summary(
&self,
input: GetAggregateConfigRuleComplianceSummaryRequest,
) -> Result<
GetAggregateConfigRuleComplianceSummaryResponse,
RusotoError<GetAggregateConfigRuleComplianceSummaryError>,
>;
async fn get_aggregate_discovered_resource_counts(
&self,
input: GetAggregateDiscoveredResourceCountsRequest,
) -> Result<
GetAggregateDiscoveredResourceCountsResponse,
RusotoError<GetAggregateDiscoveredResourceCountsError>,
>;
async fn get_aggregate_resource_config(
&self,
input: GetAggregateResourceConfigRequest,
) -> Result<GetAggregateResourceConfigResponse, RusotoError<GetAggregateResourceConfigError>>;
async fn get_compliance_details_by_config_rule(
&self,
input: GetComplianceDetailsByConfigRuleRequest,
) -> Result<
GetComplianceDetailsByConfigRuleResponse,
RusotoError<GetComplianceDetailsByConfigRuleError>,
>;
async fn get_compliance_details_by_resource(
&self,
input: GetComplianceDetailsByResourceRequest,
) -> Result<
GetComplianceDetailsByResourceResponse,
RusotoError<GetComplianceDetailsByResourceError>,
>;
async fn get_compliance_summary_by_config_rule(
&self,
) -> Result<
GetComplianceSummaryByConfigRuleResponse,
RusotoError<GetComplianceSummaryByConfigRuleError>,
>;
async fn get_compliance_summary_by_resource_type(
&self,
input: GetComplianceSummaryByResourceTypeRequest,
) -> Result<
GetComplianceSummaryByResourceTypeResponse,
RusotoError<GetComplianceSummaryByResourceTypeError>,
>;
async fn get_conformance_pack_compliance_details(
&self,
input: GetConformancePackComplianceDetailsRequest,
) -> Result<
GetConformancePackComplianceDetailsResponse,
RusotoError<GetConformancePackComplianceDetailsError>,
>;
async fn get_conformance_pack_compliance_summary(
&self,
input: GetConformancePackComplianceSummaryRequest,
) -> Result<
GetConformancePackComplianceSummaryResponse,
RusotoError<GetConformancePackComplianceSummaryError>,
>;
async fn get_discovered_resource_counts(
&self,
input: GetDiscoveredResourceCountsRequest,
) -> Result<GetDiscoveredResourceCountsResponse, RusotoError<GetDiscoveredResourceCountsError>>;
async fn get_organization_config_rule_detailed_status(
&self,
input: GetOrganizationConfigRuleDetailedStatusRequest,
) -> Result<
GetOrganizationConfigRuleDetailedStatusResponse,
RusotoError<GetOrganizationConfigRuleDetailedStatusError>,
>;
async fn get_organization_conformance_pack_detailed_status(
&self,
input: GetOrganizationConformancePackDetailedStatusRequest,
) -> Result<
GetOrganizationConformancePackDetailedStatusResponse,
RusotoError<GetOrganizationConformancePackDetailedStatusError>,
>;
async fn get_resource_config_history(
&self,
input: GetResourceConfigHistoryRequest,
) -> Result<GetResourceConfigHistoryResponse, RusotoError<GetResourceConfigHistoryError>>;
async fn list_aggregate_discovered_resources(
&self,
input: ListAggregateDiscoveredResourcesRequest,
) -> Result<
ListAggregateDiscoveredResourcesResponse,
RusotoError<ListAggregateDiscoveredResourcesError>,
>;
async fn list_discovered_resources(
&self,
input: ListDiscoveredResourcesRequest,
) -> Result<ListDiscoveredResourcesResponse, RusotoError<ListDiscoveredResourcesError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
async fn put_aggregation_authorization(
&self,
input: PutAggregationAuthorizationRequest,
) -> Result<PutAggregationAuthorizationResponse, RusotoError<PutAggregationAuthorizationError>>;
async fn put_config_rule(
&self,
input: PutConfigRuleRequest,
) -> Result<(), RusotoError<PutConfigRuleError>>;
async fn put_configuration_aggregator(
&self,
input: PutConfigurationAggregatorRequest,
) -> Result<PutConfigurationAggregatorResponse, RusotoError<PutConfigurationAggregatorError>>;
async fn put_configuration_recorder(
&self,
input: PutConfigurationRecorderRequest,
) -> Result<(), RusotoError<PutConfigurationRecorderError>>;
async fn put_conformance_pack(
&self,
input: PutConformancePackRequest,
) -> Result<PutConformancePackResponse, RusotoError<PutConformancePackError>>;
async fn put_delivery_channel(
&self,
input: PutDeliveryChannelRequest,
) -> Result<(), RusotoError<PutDeliveryChannelError>>;
async fn put_evaluations(
&self,
input: PutEvaluationsRequest,
) -> Result<PutEvaluationsResponse, RusotoError<PutEvaluationsError>>;
async fn put_organization_config_rule(
&self,
input: PutOrganizationConfigRuleRequest,
) -> Result<PutOrganizationConfigRuleResponse, RusotoError<PutOrganizationConfigRuleError>>;
async fn put_organization_conformance_pack(
&self,
input: PutOrganizationConformancePackRequest,
) -> Result<
PutOrganizationConformancePackResponse,
RusotoError<PutOrganizationConformancePackError>,
>;
async fn put_remediation_configurations(
&self,
input: PutRemediationConfigurationsRequest,
) -> Result<PutRemediationConfigurationsResponse, RusotoError<PutRemediationConfigurationsError>>;
async fn put_remediation_exceptions(
&self,
input: PutRemediationExceptionsRequest,
) -> Result<PutRemediationExceptionsResponse, RusotoError<PutRemediationExceptionsError>>;
async fn put_resource_config(
&self,
input: PutResourceConfigRequest,
) -> Result<(), RusotoError<PutResourceConfigError>>;
async fn put_retention_configuration(
&self,
input: PutRetentionConfigurationRequest,
) -> Result<PutRetentionConfigurationResponse, RusotoError<PutRetentionConfigurationError>>;
async fn select_aggregate_resource_config(
&self,
input: SelectAggregateResourceConfigRequest,
) -> Result<
SelectAggregateResourceConfigResponse,
RusotoError<SelectAggregateResourceConfigError>,
>;
async fn select_resource_config(
&self,
input: SelectResourceConfigRequest,
) -> Result<SelectResourceConfigResponse, RusotoError<SelectResourceConfigError>>;
async fn start_config_rules_evaluation(
&self,
input: StartConfigRulesEvaluationRequest,
) -> Result<StartConfigRulesEvaluationResponse, RusotoError<StartConfigRulesEvaluationError>>;
async fn start_configuration_recorder(
&self,
input: StartConfigurationRecorderRequest,
) -> Result<(), RusotoError<StartConfigurationRecorderError>>;
async fn start_remediation_execution(
&self,
input: StartRemediationExecutionRequest,
) -> Result<StartRemediationExecutionResponse, RusotoError<StartRemediationExecutionError>>;
async fn stop_configuration_recorder(
&self,
input: StopConfigurationRecorderRequest,
) -> Result<(), RusotoError<StopConfigurationRecorderError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<(), RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<(), RusotoError<UntagResourceError>>;
}
#[derive(Clone)]
pub struct ConfigServiceClient {
client: Client,
region: region::Region,
}
impl ConfigServiceClient {
pub fn new(region: region::Region) -> ConfigServiceClient {
ConfigServiceClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> ConfigServiceClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
ConfigServiceClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> ConfigServiceClient {
ConfigServiceClient { client, region }
}
}
#[async_trait]
impl ConfigService for ConfigServiceClient {
async fn batch_get_aggregate_resource_config(
&self,
input: BatchGetAggregateResourceConfigRequest,
) -> Result<
BatchGetAggregateResourceConfigResponse,
RusotoError<BatchGetAggregateResourceConfigError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.BatchGetAggregateResourceConfig",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, BatchGetAggregateResourceConfigError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<BatchGetAggregateResourceConfigResponse, _>()
}
async fn batch_get_resource_config(
&self,
input: BatchGetResourceConfigRequest,
) -> Result<BatchGetResourceConfigResponse, RusotoError<BatchGetResourceConfigError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "StarlingDoveService.BatchGetResourceConfig");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, BatchGetResourceConfigError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<BatchGetResourceConfigResponse, _>()
}
async fn delete_aggregation_authorization(
&self,
input: DeleteAggregationAuthorizationRequest,
) -> Result<(), RusotoError<DeleteAggregationAuthorizationError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DeleteAggregationAuthorization",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteAggregationAuthorizationError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_config_rule(
&self,
input: DeleteConfigRuleRequest,
) -> Result<(), RusotoError<DeleteConfigRuleError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "StarlingDoveService.DeleteConfigRule");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteConfigRuleError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_configuration_aggregator(
&self,
input: DeleteConfigurationAggregatorRequest,
) -> Result<(), RusotoError<DeleteConfigurationAggregatorError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DeleteConfigurationAggregator",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteConfigurationAggregatorError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_configuration_recorder(
&self,
input: DeleteConfigurationRecorderRequest,
) -> Result<(), RusotoError<DeleteConfigurationRecorderError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DeleteConfigurationRecorder",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteConfigurationRecorderError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_conformance_pack(
&self,
input: DeleteConformancePackRequest,
) -> Result<(), RusotoError<DeleteConformancePackError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "StarlingDoveService.DeleteConformancePack");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteConformancePackError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_delivery_channel(
&self,
input: DeleteDeliveryChannelRequest,
) -> Result<(), RusotoError<DeleteDeliveryChannelError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "StarlingDoveService.DeleteDeliveryChannel");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteDeliveryChannelError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_evaluation_results(
&self,
input: DeleteEvaluationResultsRequest,
) -> Result<DeleteEvaluationResultsResponse, RusotoError<DeleteEvaluationResultsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DeleteEvaluationResults",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteEvaluationResultsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteEvaluationResultsResponse, _>()
}
async fn delete_organization_config_rule(
&self,
input: DeleteOrganizationConfigRuleRequest,
) -> Result<(), RusotoError<DeleteOrganizationConfigRuleError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DeleteOrganizationConfigRule",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteOrganizationConfigRuleError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_organization_conformance_pack(
&self,
input: DeleteOrganizationConformancePackRequest,
) -> Result<(), RusotoError<DeleteOrganizationConformancePackError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DeleteOrganizationConformancePack",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DeleteOrganizationConformancePackError::from_response,
)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_pending_aggregation_request(
&self,
input: DeletePendingAggregationRequestRequest,
) -> Result<(), RusotoError<DeletePendingAggregationRequestError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DeletePendingAggregationRequest",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeletePendingAggregationRequestError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_remediation_configuration(
&self,
input: DeleteRemediationConfigurationRequest,
) -> Result<
DeleteRemediationConfigurationResponse,
RusotoError<DeleteRemediationConfigurationError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DeleteRemediationConfiguration",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteRemediationConfigurationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteRemediationConfigurationResponse, _>()
}
async fn delete_remediation_exceptions(
&self,
input: DeleteRemediationExceptionsRequest,
) -> Result<DeleteRemediationExceptionsResponse, RusotoError<DeleteRemediationExceptionsError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DeleteRemediationExceptions",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteRemediationExceptionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteRemediationExceptionsResponse, _>()
}
async fn delete_resource_config(
&self,
input: DeleteResourceConfigRequest,
) -> Result<(), RusotoError<DeleteResourceConfigError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "StarlingDoveService.DeleteResourceConfig");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteResourceConfigError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn delete_retention_configuration(
&self,
input: DeleteRetentionConfigurationRequest,
) -> Result<(), RusotoError<DeleteRetentionConfigurationError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DeleteRetentionConfiguration",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteRetentionConfigurationError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn deliver_config_snapshot(
&self,
input: DeliverConfigSnapshotRequest,
) -> Result<DeliverConfigSnapshotResponse, RusotoError<DeliverConfigSnapshotError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "StarlingDoveService.DeliverConfigSnapshot");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeliverConfigSnapshotError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeliverConfigSnapshotResponse, _>()
}
async fn describe_aggregate_compliance_by_config_rules(
&self,
input: DescribeAggregateComplianceByConfigRulesRequest,
) -> Result<
DescribeAggregateComplianceByConfigRulesResponse,
RusotoError<DescribeAggregateComplianceByConfigRulesError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DescribeAggregateComplianceByConfigRules",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DescribeAggregateComplianceByConfigRulesError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeAggregateComplianceByConfigRulesResponse, _>()
}
async fn describe_aggregation_authorizations(
&self,
input: DescribeAggregationAuthorizationsRequest,
) -> Result<
DescribeAggregationAuthorizationsResponse,
RusotoError<DescribeAggregationAuthorizationsError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DescribeAggregationAuthorizations",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DescribeAggregationAuthorizationsError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeAggregationAuthorizationsResponse, _>()
}
async fn describe_compliance_by_config_rule(
&self,
input: DescribeComplianceByConfigRuleRequest,
) -> Result<
DescribeComplianceByConfigRuleResponse,
RusotoError<DescribeComplianceByConfigRuleError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DescribeComplianceByConfigRule",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeComplianceByConfigRuleError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeComplianceByConfigRuleResponse, _>()
}
async fn describe_compliance_by_resource(
&self,
input: DescribeComplianceByResourceRequest,
) -> Result<DescribeComplianceByResourceResponse, RusotoError<DescribeComplianceByResourceError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DescribeComplianceByResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeComplianceByResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeComplianceByResourceResponse, _>()
}
async fn describe_config_rule_evaluation_status(
&self,
input: DescribeConfigRuleEvaluationStatusRequest,
) -> Result<
DescribeConfigRuleEvaluationStatusResponse,
RusotoError<DescribeConfigRuleEvaluationStatusError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DescribeConfigRuleEvaluationStatus",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DescribeConfigRuleEvaluationStatusError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeConfigRuleEvaluationStatusResponse, _>()
}
async fn describe_config_rules(
&self,
input: DescribeConfigRulesRequest,
) -> Result<DescribeConfigRulesResponse, RusotoError<DescribeConfigRulesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "StarlingDoveService.DescribeConfigRules");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeConfigRulesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeConfigRulesResponse, _>()
}
async fn describe_configuration_aggregator_sources_status(
&self,
input: DescribeConfigurationAggregatorSourcesStatusRequest,
) -> Result<
DescribeConfigurationAggregatorSourcesStatusResponse,
RusotoError<DescribeConfigurationAggregatorSourcesStatusError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DescribeConfigurationAggregatorSourcesStatus",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DescribeConfigurationAggregatorSourcesStatusError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeConfigurationAggregatorSourcesStatusResponse, _>()
}
async fn describe_configuration_aggregators(
&self,
input: DescribeConfigurationAggregatorsRequest,
) -> Result<
DescribeConfigurationAggregatorsResponse,
RusotoError<DescribeConfigurationAggregatorsError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DescribeConfigurationAggregators",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DescribeConfigurationAggregatorsError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeConfigurationAggregatorsResponse, _>()
}
async fn describe_configuration_recorder_status(
&self,
input: DescribeConfigurationRecorderStatusRequest,
) -> Result<
DescribeConfigurationRecorderStatusResponse,
RusotoError<DescribeConfigurationRecorderStatusError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DescribeConfigurationRecorderStatus",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DescribeConfigurationRecorderStatusError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeConfigurationRecorderStatusResponse, _>()
}
async fn describe_configuration_recorders(
&self,
input: DescribeConfigurationRecordersRequest,
) -> Result<
DescribeConfigurationRecordersResponse,
RusotoError<DescribeConfigurationRecordersError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DescribeConfigurationRecorders",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeConfigurationRecordersError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeConfigurationRecordersResponse, _>()
}
async fn describe_conformance_pack_compliance(
&self,
input: DescribeConformancePackComplianceRequest,
) -> Result<
DescribeConformancePackComplianceResponse,
RusotoError<DescribeConformancePackComplianceError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DescribeConformancePackCompliance",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DescribeConformancePackComplianceError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeConformancePackComplianceResponse, _>()
}
async fn describe_conformance_pack_status(
&self,
input: DescribeConformancePackStatusRequest,
) -> Result<
DescribeConformancePackStatusResponse,
RusotoError<DescribeConformancePackStatusError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DescribeConformancePackStatus",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeConformancePackStatusError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeConformancePackStatusResponse, _>()
}
async fn describe_conformance_packs(
&self,
input: DescribeConformancePacksRequest,
) -> Result<DescribeConformancePacksResponse, RusotoError<DescribeConformancePacksError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DescribeConformancePacks",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeConformancePacksError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeConformancePacksResponse, _>()
}
async fn describe_delivery_channel_status(
&self,
input: DescribeDeliveryChannelStatusRequest,
) -> Result<
DescribeDeliveryChannelStatusResponse,
RusotoError<DescribeDeliveryChannelStatusError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DescribeDeliveryChannelStatus",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeDeliveryChannelStatusError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeDeliveryChannelStatusResponse, _>()
}
async fn describe_delivery_channels(
&self,
input: DescribeDeliveryChannelsRequest,
) -> Result<DescribeDeliveryChannelsResponse, RusotoError<DescribeDeliveryChannelsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DescribeDeliveryChannels",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeDeliveryChannelsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeDeliveryChannelsResponse, _>()
}
async fn describe_organization_config_rule_statuses(
&self,
input: DescribeOrganizationConfigRuleStatusesRequest,
) -> Result<
DescribeOrganizationConfigRuleStatusesResponse,
RusotoError<DescribeOrganizationConfigRuleStatusesError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DescribeOrganizationConfigRuleStatuses",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DescribeOrganizationConfigRuleStatusesError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeOrganizationConfigRuleStatusesResponse, _>()
}
async fn describe_organization_config_rules(
&self,
input: DescribeOrganizationConfigRulesRequest,
) -> Result<
DescribeOrganizationConfigRulesResponse,
RusotoError<DescribeOrganizationConfigRulesError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DescribeOrganizationConfigRules",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeOrganizationConfigRulesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeOrganizationConfigRulesResponse, _>()
}
async fn describe_organization_conformance_pack_statuses(
&self,
input: DescribeOrganizationConformancePackStatusesRequest,
) -> Result<
DescribeOrganizationConformancePackStatusesResponse,
RusotoError<DescribeOrganizationConformancePackStatusesError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DescribeOrganizationConformancePackStatuses",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DescribeOrganizationConformancePackStatusesError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeOrganizationConformancePackStatusesResponse, _>()
}
async fn describe_organization_conformance_packs(
&self,
input: DescribeOrganizationConformancePacksRequest,
) -> Result<
DescribeOrganizationConformancePacksResponse,
RusotoError<DescribeOrganizationConformancePacksError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DescribeOrganizationConformancePacks",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DescribeOrganizationConformancePacksError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeOrganizationConformancePacksResponse, _>()
}
async fn describe_pending_aggregation_requests(
&self,
input: DescribePendingAggregationRequestsRequest,
) -> Result<
DescribePendingAggregationRequestsResponse,
RusotoError<DescribePendingAggregationRequestsError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DescribePendingAggregationRequests",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DescribePendingAggregationRequestsError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribePendingAggregationRequestsResponse, _>()
}
async fn describe_remediation_configurations(
&self,
input: DescribeRemediationConfigurationsRequest,
) -> Result<
DescribeRemediationConfigurationsResponse,
RusotoError<DescribeRemediationConfigurationsError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DescribeRemediationConfigurations",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DescribeRemediationConfigurationsError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeRemediationConfigurationsResponse, _>()
}
async fn describe_remediation_exceptions(
&self,
input: DescribeRemediationExceptionsRequest,
) -> Result<
DescribeRemediationExceptionsResponse,
RusotoError<DescribeRemediationExceptionsError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DescribeRemediationExceptions",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeRemediationExceptionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeRemediationExceptionsResponse, _>()
}
async fn describe_remediation_execution_status(
&self,
input: DescribeRemediationExecutionStatusRequest,
) -> Result<
DescribeRemediationExecutionStatusResponse,
RusotoError<DescribeRemediationExecutionStatusError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DescribeRemediationExecutionStatus",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DescribeRemediationExecutionStatusError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeRemediationExecutionStatusResponse, _>()
}
async fn describe_retention_configurations(
&self,
input: DescribeRetentionConfigurationsRequest,
) -> Result<
DescribeRetentionConfigurationsResponse,
RusotoError<DescribeRetentionConfigurationsError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.DescribeRetentionConfigurations",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeRetentionConfigurationsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeRetentionConfigurationsResponse, _>()
}
async fn get_aggregate_compliance_details_by_config_rule(
&self,
input: GetAggregateComplianceDetailsByConfigRuleRequest,
) -> Result<
GetAggregateComplianceDetailsByConfigRuleResponse,
RusotoError<GetAggregateComplianceDetailsByConfigRuleError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.GetAggregateComplianceDetailsByConfigRule",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
GetAggregateComplianceDetailsByConfigRuleError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetAggregateComplianceDetailsByConfigRuleResponse, _>()
}
async fn get_aggregate_config_rule_compliance_summary(
&self,
input: GetAggregateConfigRuleComplianceSummaryRequest,
) -> Result<
GetAggregateConfigRuleComplianceSummaryResponse,
RusotoError<GetAggregateConfigRuleComplianceSummaryError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.GetAggregateConfigRuleComplianceSummary",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
GetAggregateConfigRuleComplianceSummaryError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetAggregateConfigRuleComplianceSummaryResponse, _>()
}
async fn get_aggregate_discovered_resource_counts(
&self,
input: GetAggregateDiscoveredResourceCountsRequest,
) -> Result<
GetAggregateDiscoveredResourceCountsResponse,
RusotoError<GetAggregateDiscoveredResourceCountsError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.GetAggregateDiscoveredResourceCounts",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
GetAggregateDiscoveredResourceCountsError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetAggregateDiscoveredResourceCountsResponse, _>()
}
async fn get_aggregate_resource_config(
&self,
input: GetAggregateResourceConfigRequest,
) -> Result<GetAggregateResourceConfigResponse, RusotoError<GetAggregateResourceConfigError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.GetAggregateResourceConfig",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetAggregateResourceConfigError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetAggregateResourceConfigResponse, _>()
}
async fn get_compliance_details_by_config_rule(
&self,
input: GetComplianceDetailsByConfigRuleRequest,
) -> Result<
GetComplianceDetailsByConfigRuleResponse,
RusotoError<GetComplianceDetailsByConfigRuleError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.GetComplianceDetailsByConfigRule",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
GetComplianceDetailsByConfigRuleError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetComplianceDetailsByConfigRuleResponse, _>()
}
async fn get_compliance_details_by_resource(
&self,
input: GetComplianceDetailsByResourceRequest,
) -> Result<
GetComplianceDetailsByResourceResponse,
RusotoError<GetComplianceDetailsByResourceError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.GetComplianceDetailsByResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetComplianceDetailsByResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetComplianceDetailsByResourceResponse, _>()
}
async fn get_compliance_summary_by_config_rule(
&self,
) -> Result<
GetComplianceSummaryByConfigRuleResponse,
RusotoError<GetComplianceSummaryByConfigRuleError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.GetComplianceSummaryByConfigRule",
);
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(
request,
GetComplianceSummaryByConfigRuleError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetComplianceSummaryByConfigRuleResponse, _>()
}
async fn get_compliance_summary_by_resource_type(
&self,
input: GetComplianceSummaryByResourceTypeRequest,
) -> Result<
GetComplianceSummaryByResourceTypeResponse,
RusotoError<GetComplianceSummaryByResourceTypeError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.GetComplianceSummaryByResourceType",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
GetComplianceSummaryByResourceTypeError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetComplianceSummaryByResourceTypeResponse, _>()
}
async fn get_conformance_pack_compliance_details(
&self,
input: GetConformancePackComplianceDetailsRequest,
) -> Result<
GetConformancePackComplianceDetailsResponse,
RusotoError<GetConformancePackComplianceDetailsError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.GetConformancePackComplianceDetails",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
GetConformancePackComplianceDetailsError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetConformancePackComplianceDetailsResponse, _>()
}
async fn get_conformance_pack_compliance_summary(
&self,
input: GetConformancePackComplianceSummaryRequest,
) -> Result<
GetConformancePackComplianceSummaryResponse,
RusotoError<GetConformancePackComplianceSummaryError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.GetConformancePackComplianceSummary",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
GetConformancePackComplianceSummaryError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetConformancePackComplianceSummaryResponse, _>()
}
async fn get_discovered_resource_counts(
&self,
input: GetDiscoveredResourceCountsRequest,
) -> Result<GetDiscoveredResourceCountsResponse, RusotoError<GetDiscoveredResourceCountsError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.GetDiscoveredResourceCounts",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetDiscoveredResourceCountsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetDiscoveredResourceCountsResponse, _>()
}
async fn get_organization_config_rule_detailed_status(
&self,
input: GetOrganizationConfigRuleDetailedStatusRequest,
) -> Result<
GetOrganizationConfigRuleDetailedStatusResponse,
RusotoError<GetOrganizationConfigRuleDetailedStatusError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.GetOrganizationConfigRuleDetailedStatus",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
GetOrganizationConfigRuleDetailedStatusError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetOrganizationConfigRuleDetailedStatusResponse, _>()
}
async fn get_organization_conformance_pack_detailed_status(
&self,
input: GetOrganizationConformancePackDetailedStatusRequest,
) -> Result<
GetOrganizationConformancePackDetailedStatusResponse,
RusotoError<GetOrganizationConformancePackDetailedStatusError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.GetOrganizationConformancePackDetailedStatus",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
GetOrganizationConformancePackDetailedStatusError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetOrganizationConformancePackDetailedStatusResponse, _>()
}
async fn get_resource_config_history(
&self,
input: GetResourceConfigHistoryRequest,
) -> Result<GetResourceConfigHistoryResponse, RusotoError<GetResourceConfigHistoryError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.GetResourceConfigHistory",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetResourceConfigHistoryError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetResourceConfigHistoryResponse, _>()
}
async fn list_aggregate_discovered_resources(
&self,
input: ListAggregateDiscoveredResourcesRequest,
) -> Result<
ListAggregateDiscoveredResourcesResponse,
RusotoError<ListAggregateDiscoveredResourcesError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.ListAggregateDiscoveredResources",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
ListAggregateDiscoveredResourcesError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListAggregateDiscoveredResourcesResponse, _>()
}
async fn list_discovered_resources(
&self,
input: ListDiscoveredResourcesRequest,
) -> Result<ListDiscoveredResourcesResponse, RusotoError<ListDiscoveredResourcesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.ListDiscoveredResources",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListDiscoveredResourcesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListDiscoveredResourcesResponse, _>()
}
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "StarlingDoveService.ListTagsForResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListTagsForResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListTagsForResourceResponse, _>()
}
async fn put_aggregation_authorization(
&self,
input: PutAggregationAuthorizationRequest,
) -> Result<PutAggregationAuthorizationResponse, RusotoError<PutAggregationAuthorizationError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.PutAggregationAuthorization",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, PutAggregationAuthorizationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<PutAggregationAuthorizationResponse, _>()
}
async fn put_config_rule(
&self,
input: PutConfigRuleRequest,
) -> Result<(), RusotoError<PutConfigRuleError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "StarlingDoveService.PutConfigRule");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, PutConfigRuleError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn put_configuration_aggregator(
&self,
input: PutConfigurationAggregatorRequest,
) -> Result<PutConfigurationAggregatorResponse, RusotoError<PutConfigurationAggregatorError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.PutConfigurationAggregator",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, PutConfigurationAggregatorError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<PutConfigurationAggregatorResponse, _>()
}
async fn put_configuration_recorder(
&self,
input: PutConfigurationRecorderRequest,
) -> Result<(), RusotoError<PutConfigurationRecorderError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.PutConfigurationRecorder",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, PutConfigurationRecorderError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn put_conformance_pack(
&self,
input: PutConformancePackRequest,
) -> Result<PutConformancePackResponse, RusotoError<PutConformancePackError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "StarlingDoveService.PutConformancePack");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, PutConformancePackError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<PutConformancePackResponse, _>()
}
async fn put_delivery_channel(
&self,
input: PutDeliveryChannelRequest,
) -> Result<(), RusotoError<PutDeliveryChannelError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "StarlingDoveService.PutDeliveryChannel");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, PutDeliveryChannelError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn put_evaluations(
&self,
input: PutEvaluationsRequest,
) -> Result<PutEvaluationsResponse, RusotoError<PutEvaluationsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "StarlingDoveService.PutEvaluations");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, PutEvaluationsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<PutEvaluationsResponse, _>()
}
async fn put_organization_config_rule(
&self,
input: PutOrganizationConfigRuleRequest,
) -> Result<PutOrganizationConfigRuleResponse, RusotoError<PutOrganizationConfigRuleError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.PutOrganizationConfigRule",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, PutOrganizationConfigRuleError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<PutOrganizationConfigRuleResponse, _>()
}
async fn put_organization_conformance_pack(
&self,
input: PutOrganizationConformancePackRequest,
) -> Result<
PutOrganizationConformancePackResponse,
RusotoError<PutOrganizationConformancePackError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.PutOrganizationConformancePack",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, PutOrganizationConformancePackError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<PutOrganizationConformancePackResponse, _>()
}
async fn put_remediation_configurations(
&self,
input: PutRemediationConfigurationsRequest,
) -> Result<PutRemediationConfigurationsResponse, RusotoError<PutRemediationConfigurationsError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.PutRemediationConfigurations",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, PutRemediationConfigurationsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<PutRemediationConfigurationsResponse, _>()
}
async fn put_remediation_exceptions(
&self,
input: PutRemediationExceptionsRequest,
) -> Result<PutRemediationExceptionsResponse, RusotoError<PutRemediationExceptionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.PutRemediationExceptions",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, PutRemediationExceptionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<PutRemediationExceptionsResponse, _>()
}
async fn put_resource_config(
&self,
input: PutResourceConfigRequest,
) -> Result<(), RusotoError<PutResourceConfigError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "StarlingDoveService.PutResourceConfig");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, PutResourceConfigError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn put_retention_configuration(
&self,
input: PutRetentionConfigurationRequest,
) -> Result<PutRetentionConfigurationResponse, RusotoError<PutRetentionConfigurationError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.PutRetentionConfiguration",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, PutRetentionConfigurationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<PutRetentionConfigurationResponse, _>()
}
async fn select_aggregate_resource_config(
&self,
input: SelectAggregateResourceConfigRequest,
) -> Result<
SelectAggregateResourceConfigResponse,
RusotoError<SelectAggregateResourceConfigError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.SelectAggregateResourceConfig",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, SelectAggregateResourceConfigError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<SelectAggregateResourceConfigResponse, _>()
}
async fn select_resource_config(
&self,
input: SelectResourceConfigRequest,
) -> Result<SelectResourceConfigResponse, RusotoError<SelectResourceConfigError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "StarlingDoveService.SelectResourceConfig");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, SelectResourceConfigError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<SelectResourceConfigResponse, _>()
}
async fn start_config_rules_evaluation(
&self,
input: StartConfigRulesEvaluationRequest,
) -> Result<StartConfigRulesEvaluationResponse, RusotoError<StartConfigRulesEvaluationError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.StartConfigRulesEvaluation",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StartConfigRulesEvaluationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<StartConfigRulesEvaluationResponse, _>()
}
async fn start_configuration_recorder(
&self,
input: StartConfigurationRecorderRequest,
) -> Result<(), RusotoError<StartConfigurationRecorderError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.StartConfigurationRecorder",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StartConfigurationRecorderError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn start_remediation_execution(
&self,
input: StartRemediationExecutionRequest,
) -> Result<StartRemediationExecutionResponse, RusotoError<StartRemediationExecutionError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.StartRemediationExecution",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StartRemediationExecutionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<StartRemediationExecutionResponse, _>()
}
async fn stop_configuration_recorder(
&self,
input: StopConfigurationRecorderRequest,
) -> Result<(), RusotoError<StopConfigurationRecorderError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"StarlingDoveService.StopConfigurationRecorder",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, StopConfigurationRecorderError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<(), RusotoError<TagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "StarlingDoveService.TagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, TagResourceError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<(), RusotoError<UntagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "StarlingDoveService.UntagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UntagResourceError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
}