use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::param::{Params, ServiceParams};
use rusoto_core::proto;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
use serde_json;
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AcceptInvitationRequest {
#[serde(rename = "DetectorId")]
pub detector_id: String,
#[serde(rename = "InvitationId")]
pub invitation_id: String,
#[serde(rename = "MasterId")]
pub master_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AcceptInvitationResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AccessControlList {
#[serde(rename = "AllowsPublicReadAccess")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allows_public_read_access: Option<bool>,
#[serde(rename = "AllowsPublicWriteAccess")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allows_public_write_access: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AccessKeyDetails {
#[serde(rename = "AccessKeyId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_key_id: Option<String>,
#[serde(rename = "PrincipalId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub principal_id: Option<String>,
#[serde(rename = "UserName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_name: Option<String>,
#[serde(rename = "UserType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_type: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AccountDetail {
#[serde(rename = "AccountId")]
pub account_id: String,
#[serde(rename = "Email")]
pub email: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AccountLevelPermissions {
#[serde(rename = "BlockPublicAccess")]
#[serde(skip_serializing_if = "Option::is_none")]
pub block_public_access: Option<BlockPublicAccess>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Action {
#[serde(rename = "ActionType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub action_type: Option<String>,
#[serde(rename = "AwsApiCallAction")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aws_api_call_action: Option<AwsApiCallAction>,
#[serde(rename = "DnsRequestAction")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dns_request_action: Option<DnsRequestAction>,
#[serde(rename = "NetworkConnectionAction")]
#[serde(skip_serializing_if = "Option::is_none")]
pub network_connection_action: Option<NetworkConnectionAction>,
#[serde(rename = "PortProbeAction")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port_probe_action: Option<PortProbeAction>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AdminAccount {
#[serde(rename = "AdminAccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub admin_account_id: Option<String>,
#[serde(rename = "AdminStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub admin_status: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ArchiveFindingsRequest {
#[serde(rename = "DetectorId")]
pub detector_id: String,
#[serde(rename = "FindingIds")]
pub finding_ids: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ArchiveFindingsResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AwsApiCallAction {
#[serde(rename = "Api")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api: Option<String>,
#[serde(rename = "CallerType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub caller_type: Option<String>,
#[serde(rename = "DomainDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_details: Option<DomainDetails>,
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "RemoteIpDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remote_ip_details: Option<RemoteIpDetails>,
#[serde(rename = "ServiceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BlockPublicAccess {
#[serde(rename = "BlockPublicAcls")]
#[serde(skip_serializing_if = "Option::is_none")]
pub block_public_acls: Option<bool>,
#[serde(rename = "BlockPublicPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub block_public_policy: Option<bool>,
#[serde(rename = "IgnorePublicAcls")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ignore_public_acls: Option<bool>,
#[serde(rename = "RestrictPublicBuckets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub restrict_public_buckets: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BucketLevelPermissions {
#[serde(rename = "AccessControlList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_control_list: Option<AccessControlList>,
#[serde(rename = "BlockPublicAccess")]
#[serde(skip_serializing_if = "Option::is_none")]
pub block_public_access: Option<BlockPublicAccess>,
#[serde(rename = "BucketPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bucket_policy: Option<BucketPolicy>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BucketPolicy {
#[serde(rename = "AllowsPublicReadAccess")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allows_public_read_access: Option<bool>,
#[serde(rename = "AllowsPublicWriteAccess")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allows_public_write_access: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct City {
#[serde(rename = "CityName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub city_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CloudTrailConfigurationResult {
#[serde(rename = "Status")]
pub status: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Condition {
#[serde(rename = "Equals")]
#[serde(skip_serializing_if = "Option::is_none")]
pub equals: Option<Vec<String>>,
#[serde(rename = "GreaterThan")]
#[serde(skip_serializing_if = "Option::is_none")]
pub greater_than: Option<i64>,
#[serde(rename = "GreaterThanOrEqual")]
#[serde(skip_serializing_if = "Option::is_none")]
pub greater_than_or_equal: Option<i64>,
#[serde(rename = "LessThan")]
#[serde(skip_serializing_if = "Option::is_none")]
pub less_than: Option<i64>,
#[serde(rename = "LessThanOrEqual")]
#[serde(skip_serializing_if = "Option::is_none")]
pub less_than_or_equal: Option<i64>,
#[serde(rename = "NotEquals")]
#[serde(skip_serializing_if = "Option::is_none")]
pub not_equals: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Country {
#[serde(rename = "CountryCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub country_code: Option<String>,
#[serde(rename = "CountryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub country_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDetectorRequest {
#[serde(rename = "ClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "DataSources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_sources: Option<DataSourceConfigurations>,
#[serde(rename = "Enable")]
pub enable: bool,
#[serde(rename = "FindingPublishingFrequency")]
#[serde(skip_serializing_if = "Option::is_none")]
pub finding_publishing_frequency: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDetectorResponse {
#[serde(rename = "DetectorId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub detector_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateFilterRequest {
#[serde(rename = "Action")]
#[serde(skip_serializing_if = "Option::is_none")]
pub action: Option<String>,
#[serde(rename = "ClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DetectorId")]
pub detector_id: String,
#[serde(rename = "FindingCriteria")]
pub finding_criteria: FindingCriteria,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Rank")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rank: Option<i64>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateFilterResponse {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateIPSetRequest {
#[serde(rename = "Activate")]
pub activate: bool,
#[serde(rename = "ClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "DetectorId")]
pub detector_id: String,
#[serde(rename = "Format")]
pub format: String,
#[serde(rename = "Location")]
pub location: String,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateIPSetResponse {
#[serde(rename = "IpSetId")]
pub ip_set_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateMembersRequest {
#[serde(rename = "AccountDetails")]
pub account_details: Vec<AccountDetail>,
#[serde(rename = "DetectorId")]
pub detector_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateMembersResponse {
#[serde(rename = "UnprocessedAccounts")]
pub unprocessed_accounts: Vec<UnprocessedAccount>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreatePublishingDestinationRequest {
#[serde(rename = "ClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "DestinationProperties")]
pub destination_properties: DestinationProperties,
#[serde(rename = "DestinationType")]
pub destination_type: String,
#[serde(rename = "DetectorId")]
pub detector_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreatePublishingDestinationResponse {
#[serde(rename = "DestinationId")]
pub destination_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateSampleFindingsRequest {
#[serde(rename = "DetectorId")]
pub detector_id: String,
#[serde(rename = "FindingTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub finding_types: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateSampleFindingsResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateThreatIntelSetRequest {
#[serde(rename = "Activate")]
pub activate: bool,
#[serde(rename = "ClientToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_token: Option<String>,
#[serde(rename = "DetectorId")]
pub detector_id: String,
#[serde(rename = "Format")]
pub format: String,
#[serde(rename = "Location")]
pub location: String,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateThreatIntelSetResponse {
#[serde(rename = "ThreatIntelSetId")]
pub threat_intel_set_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DNSLogsConfigurationResult {
#[serde(rename = "Status")]
pub status: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DataSourceConfigurations {
#[serde(rename = "S3Logs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_logs: Option<S3LogsConfiguration>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DataSourceConfigurationsResult {
#[serde(rename = "CloudTrail")]
pub cloud_trail: CloudTrailConfigurationResult,
#[serde(rename = "DNSLogs")]
pub dns_logs: DNSLogsConfigurationResult,
#[serde(rename = "FlowLogs")]
pub flow_logs: FlowLogsConfigurationResult,
#[serde(rename = "S3Logs")]
pub s3_logs: S3LogsConfigurationResult,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeclineInvitationsRequest {
#[serde(rename = "AccountIds")]
pub account_ids: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeclineInvitationsResponse {
#[serde(rename = "UnprocessedAccounts")]
pub unprocessed_accounts: Vec<UnprocessedAccount>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DefaultServerSideEncryption {
#[serde(rename = "EncryptionType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encryption_type: Option<String>,
#[serde(rename = "KmsMasterKeyArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_master_key_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDetectorRequest {
#[serde(rename = "DetectorId")]
pub detector_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteDetectorResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteFilterRequest {
#[serde(rename = "DetectorId")]
pub detector_id: String,
#[serde(rename = "FilterName")]
pub filter_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteFilterResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteIPSetRequest {
#[serde(rename = "DetectorId")]
pub detector_id: String,
#[serde(rename = "IpSetId")]
pub ip_set_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteIPSetResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteInvitationsRequest {
#[serde(rename = "AccountIds")]
pub account_ids: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteInvitationsResponse {
#[serde(rename = "UnprocessedAccounts")]
pub unprocessed_accounts: Vec<UnprocessedAccount>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteMembersRequest {
#[serde(rename = "AccountIds")]
pub account_ids: Vec<String>,
#[serde(rename = "DetectorId")]
pub detector_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteMembersResponse {
#[serde(rename = "UnprocessedAccounts")]
pub unprocessed_accounts: Vec<UnprocessedAccount>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeletePublishingDestinationRequest {
#[serde(rename = "DestinationId")]
pub destination_id: String,
#[serde(rename = "DetectorId")]
pub detector_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeletePublishingDestinationResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteThreatIntelSetRequest {
#[serde(rename = "DetectorId")]
pub detector_id: String,
#[serde(rename = "ThreatIntelSetId")]
pub threat_intel_set_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteThreatIntelSetResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeOrganizationConfigurationRequest {
#[serde(rename = "DetectorId")]
pub detector_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeOrganizationConfigurationResponse {
#[serde(rename = "AutoEnable")]
pub auto_enable: bool,
#[serde(rename = "DataSources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_sources: Option<OrganizationDataSourceConfigurationsResult>,
#[serde(rename = "MemberAccountLimitReached")]
pub member_account_limit_reached: bool,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribePublishingDestinationRequest {
#[serde(rename = "DestinationId")]
pub destination_id: String,
#[serde(rename = "DetectorId")]
pub detector_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribePublishingDestinationResponse {
#[serde(rename = "DestinationId")]
pub destination_id: String,
#[serde(rename = "DestinationProperties")]
pub destination_properties: DestinationProperties,
#[serde(rename = "DestinationType")]
pub destination_type: String,
#[serde(rename = "PublishingFailureStartTimestamp")]
pub publishing_failure_start_timestamp: i64,
#[serde(rename = "Status")]
pub status: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Destination {
#[serde(rename = "DestinationId")]
pub destination_id: String,
#[serde(rename = "DestinationType")]
pub destination_type: String,
#[serde(rename = "Status")]
pub status: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DestinationProperties {
#[serde(rename = "DestinationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_arn: Option<String>,
#[serde(rename = "KmsKeyArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisableOrganizationAdminAccountRequest {
#[serde(rename = "AdminAccountId")]
pub admin_account_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisableOrganizationAdminAccountResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisassociateFromMasterAccountRequest {
#[serde(rename = "DetectorId")]
pub detector_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisassociateFromMasterAccountResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisassociateMembersRequest {
#[serde(rename = "AccountIds")]
pub account_ids: Vec<String>,
#[serde(rename = "DetectorId")]
pub detector_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisassociateMembersResponse {
#[serde(rename = "UnprocessedAccounts")]
pub unprocessed_accounts: Vec<UnprocessedAccount>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DnsRequestAction {
#[serde(rename = "Domain")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DomainDetails {
#[serde(rename = "Domain")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct EnableOrganizationAdminAccountRequest {
#[serde(rename = "AdminAccountId")]
pub admin_account_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EnableOrganizationAdminAccountResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Evidence {
#[serde(rename = "ThreatIntelligenceDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub threat_intelligence_details: Option<Vec<ThreatIntelligenceDetail>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Finding {
#[serde(rename = "AccountId")]
pub account_id: String,
#[serde(rename = "Arn")]
pub arn: String,
#[serde(rename = "Confidence")]
#[serde(skip_serializing_if = "Option::is_none")]
pub confidence: Option<f64>,
#[serde(rename = "CreatedAt")]
pub created_at: String,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "Partition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub partition: Option<String>,
#[serde(rename = "Region")]
pub region: String,
#[serde(rename = "Resource")]
pub resource: Resource,
#[serde(rename = "SchemaVersion")]
pub schema_version: String,
#[serde(rename = "Service")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service: Option<Service>,
#[serde(rename = "Severity")]
pub severity: f64,
#[serde(rename = "Title")]
#[serde(skip_serializing_if = "Option::is_none")]
pub title: Option<String>,
#[serde(rename = "Type")]
pub type_: String,
#[serde(rename = "UpdatedAt")]
pub updated_at: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct FindingCriteria {
#[serde(rename = "Criterion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub criterion: Option<::std::collections::HashMap<String, Condition>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FindingStatistics {
#[serde(rename = "CountBySeverity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub count_by_severity: Option<::std::collections::HashMap<String, i64>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FlowLogsConfigurationResult {
#[serde(rename = "Status")]
pub status: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GeoLocation {
#[serde(rename = "Lat")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lat: Option<f64>,
#[serde(rename = "Lon")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lon: Option<f64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDetectorRequest {
#[serde(rename = "DetectorId")]
pub detector_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDetectorResponse {
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<String>,
#[serde(rename = "DataSources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_sources: Option<DataSourceConfigurationsResult>,
#[serde(rename = "FindingPublishingFrequency")]
#[serde(skip_serializing_if = "Option::is_none")]
pub finding_publishing_frequency: Option<String>,
#[serde(rename = "ServiceRole")]
pub service_role: String,
#[serde(rename = "Status")]
pub status: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "UpdatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub updated_at: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetFilterRequest {
#[serde(rename = "DetectorId")]
pub detector_id: String,
#[serde(rename = "FilterName")]
pub filter_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetFilterResponse {
#[serde(rename = "Action")]
pub action: String,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "FindingCriteria")]
pub finding_criteria: FindingCriteria,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Rank")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rank: Option<i64>,
#[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 GetFindingsRequest {
#[serde(rename = "DetectorId")]
pub detector_id: String,
#[serde(rename = "FindingIds")]
pub finding_ids: Vec<String>,
#[serde(rename = "SortCriteria")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sort_criteria: Option<SortCriteria>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetFindingsResponse {
#[serde(rename = "Findings")]
pub findings: Vec<Finding>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetFindingsStatisticsRequest {
#[serde(rename = "DetectorId")]
pub detector_id: String,
#[serde(rename = "FindingCriteria")]
#[serde(skip_serializing_if = "Option::is_none")]
pub finding_criteria: Option<FindingCriteria>,
#[serde(rename = "FindingStatisticTypes")]
pub finding_statistic_types: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetFindingsStatisticsResponse {
#[serde(rename = "FindingStatistics")]
pub finding_statistics: FindingStatistics,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetIPSetRequest {
#[serde(rename = "DetectorId")]
pub detector_id: String,
#[serde(rename = "IpSetId")]
pub ip_set_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetIPSetResponse {
#[serde(rename = "Format")]
pub format: String,
#[serde(rename = "Location")]
pub location: String,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Status")]
pub status: 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 GetInvitationsCountRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetInvitationsCountResponse {
#[serde(rename = "InvitationsCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub invitations_count: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetMasterAccountRequest {
#[serde(rename = "DetectorId")]
pub detector_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetMasterAccountResponse {
#[serde(rename = "Master")]
pub master: Master,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetMemberDetectorsRequest {
#[serde(rename = "AccountIds")]
pub account_ids: Vec<String>,
#[serde(rename = "DetectorId")]
pub detector_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetMemberDetectorsResponse {
#[serde(rename = "MemberDataSourceConfigurations")]
pub member_data_source_configurations: Vec<MemberDataSourceConfiguration>,
#[serde(rename = "UnprocessedAccounts")]
pub unprocessed_accounts: Vec<UnprocessedAccount>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetMembersRequest {
#[serde(rename = "AccountIds")]
pub account_ids: Vec<String>,
#[serde(rename = "DetectorId")]
pub detector_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetMembersResponse {
#[serde(rename = "Members")]
pub members: Vec<Member>,
#[serde(rename = "UnprocessedAccounts")]
pub unprocessed_accounts: Vec<UnprocessedAccount>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetThreatIntelSetRequest {
#[serde(rename = "DetectorId")]
pub detector_id: String,
#[serde(rename = "ThreatIntelSetId")]
pub threat_intel_set_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetThreatIntelSetResponse {
#[serde(rename = "Format")]
pub format: String,
#[serde(rename = "Location")]
pub location: String,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Status")]
pub status: 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 GetUsageStatisticsRequest {
#[serde(rename = "DetectorId")]
pub detector_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Unit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unit: Option<String>,
#[serde(rename = "UsageCriteria")]
pub usage_criteria: UsageCriteria,
#[serde(rename = "UsageStatisticType")]
pub usage_statistic_type: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetUsageStatisticsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "UsageStatistics")]
#[serde(skip_serializing_if = "Option::is_none")]
pub usage_statistics: Option<UsageStatistics>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct IamInstanceProfile {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InstanceDetails {
#[serde(rename = "AvailabilityZone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub availability_zone: Option<String>,
#[serde(rename = "IamInstanceProfile")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_instance_profile: Option<IamInstanceProfile>,
#[serde(rename = "ImageDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_description: Option<String>,
#[serde(rename = "ImageId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_id: Option<String>,
#[serde(rename = "InstanceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_id: Option<String>,
#[serde(rename = "InstanceState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_state: Option<String>,
#[serde(rename = "InstanceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_type: Option<String>,
#[serde(rename = "LaunchTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub launch_time: Option<String>,
#[serde(rename = "NetworkInterfaces")]
#[serde(skip_serializing_if = "Option::is_none")]
pub network_interfaces: Option<Vec<NetworkInterface>>,
#[serde(rename = "OutpostArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub outpost_arn: Option<String>,
#[serde(rename = "Platform")]
#[serde(skip_serializing_if = "Option::is_none")]
pub platform: Option<String>,
#[serde(rename = "ProductCodes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_codes: Option<Vec<ProductCode>>,
#[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 Invitation {
#[serde(rename = "AccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_id: Option<String>,
#[serde(rename = "InvitationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub invitation_id: Option<String>,
#[serde(rename = "InvitedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub invited_at: Option<String>,
#[serde(rename = "RelationshipStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relationship_status: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct InviteMembersRequest {
#[serde(rename = "AccountIds")]
pub account_ids: Vec<String>,
#[serde(rename = "DetectorId")]
pub detector_id: String,
#[serde(rename = "DisableEmailNotification")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disable_email_notification: Option<bool>,
#[serde(rename = "Message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InviteMembersResponse {
#[serde(rename = "UnprocessedAccounts")]
pub unprocessed_accounts: Vec<UnprocessedAccount>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDetectorsRequest {
#[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 ListDetectorsResponse {
#[serde(rename = "DetectorIds")]
pub detector_ids: Vec<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 ListFiltersRequest {
#[serde(rename = "DetectorId")]
pub detector_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListFiltersResponse {
#[serde(rename = "FilterNames")]
pub filter_names: Vec<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 ListFindingsRequest {
#[serde(rename = "DetectorId")]
pub detector_id: String,
#[serde(rename = "FindingCriteria")]
#[serde(skip_serializing_if = "Option::is_none")]
pub finding_criteria: Option<FindingCriteria>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "SortCriteria")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sort_criteria: Option<SortCriteria>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListFindingsResponse {
#[serde(rename = "FindingIds")]
pub finding_ids: Vec<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 ListIPSetsRequest {
#[serde(rename = "DetectorId")]
pub detector_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListIPSetsResponse {
#[serde(rename = "IpSetIds")]
pub ip_set_ids: Vec<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 ListInvitationsRequest {
#[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 ListInvitationsResponse {
#[serde(rename = "Invitations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub invitations: Option<Vec<Invitation>>,
#[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 ListMembersRequest {
#[serde(rename = "DetectorId")]
pub detector_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "OnlyAssociated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub only_associated: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListMembersResponse {
#[serde(rename = "Members")]
#[serde(skip_serializing_if = "Option::is_none")]
pub members: Option<Vec<Member>>,
#[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 ListOrganizationAdminAccountsRequest {
#[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 ListOrganizationAdminAccountsResponse {
#[serde(rename = "AdminAccounts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub admin_accounts: Option<Vec<AdminAccount>>,
#[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 ListPublishingDestinationsRequest {
#[serde(rename = "DetectorId")]
pub detector_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListPublishingDestinationsResponse {
#[serde(rename = "Destinations")]
pub destinations: Vec<Destination>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceResponse {
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListThreatIntelSetsRequest {
#[serde(rename = "DetectorId")]
pub detector_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListThreatIntelSetsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ThreatIntelSetIds")]
pub threat_intel_set_ids: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LocalIpDetails {
#[serde(rename = "IpAddressV4")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_address_v4: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LocalPortDetails {
#[serde(rename = "Port")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port: Option<i64>,
#[serde(rename = "PortName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Master {
#[serde(rename = "AccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_id: Option<String>,
#[serde(rename = "InvitationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub invitation_id: Option<String>,
#[serde(rename = "InvitedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub invited_at: Option<String>,
#[serde(rename = "RelationshipStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relationship_status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Member {
#[serde(rename = "AccountId")]
pub account_id: String,
#[serde(rename = "DetectorId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub detector_id: Option<String>,
#[serde(rename = "Email")]
pub email: String,
#[serde(rename = "InvitedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub invited_at: Option<String>,
#[serde(rename = "MasterId")]
pub master_id: String,
#[serde(rename = "RelationshipStatus")]
pub relationship_status: String,
#[serde(rename = "UpdatedAt")]
pub updated_at: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MemberDataSourceConfiguration {
#[serde(rename = "AccountId")]
pub account_id: String,
#[serde(rename = "DataSources")]
pub data_sources: DataSourceConfigurationsResult,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct NetworkConnectionAction {
#[serde(rename = "Blocked")]
#[serde(skip_serializing_if = "Option::is_none")]
pub blocked: Option<bool>,
#[serde(rename = "ConnectionDirection")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_direction: Option<String>,
#[serde(rename = "LocalIpDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub local_ip_details: Option<LocalIpDetails>,
#[serde(rename = "LocalPortDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub local_port_details: Option<LocalPortDetails>,
#[serde(rename = "Protocol")]
#[serde(skip_serializing_if = "Option::is_none")]
pub protocol: Option<String>,
#[serde(rename = "RemoteIpDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remote_ip_details: Option<RemoteIpDetails>,
#[serde(rename = "RemotePortDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remote_port_details: Option<RemotePortDetails>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct NetworkInterface {
#[serde(rename = "Ipv6Addresses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ipv_6_addresses: Option<Vec<String>>,
#[serde(rename = "NetworkInterfaceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub network_interface_id: Option<String>,
#[serde(rename = "PrivateDnsName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub private_dns_name: Option<String>,
#[serde(rename = "PrivateIpAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub private_ip_address: Option<String>,
#[serde(rename = "PrivateIpAddresses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub private_ip_addresses: Option<Vec<PrivateIpAddressDetails>>,
#[serde(rename = "PublicDnsName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub public_dns_name: Option<String>,
#[serde(rename = "PublicIp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub public_ip: Option<String>,
#[serde(rename = "SecurityGroups")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_groups: Option<Vec<SecurityGroup>>,
#[serde(rename = "SubnetId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_id: Option<String>,
#[serde(rename = "VpcId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Organization {
#[serde(rename = "Asn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub asn: Option<String>,
#[serde(rename = "AsnOrg")]
#[serde(skip_serializing_if = "Option::is_none")]
pub asn_org: Option<String>,
#[serde(rename = "Isp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub isp: Option<String>,
#[serde(rename = "Org")]
#[serde(skip_serializing_if = "Option::is_none")]
pub org: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct OrganizationDataSourceConfigurations {
#[serde(rename = "S3Logs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_logs: Option<OrganizationS3LogsConfiguration>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct OrganizationDataSourceConfigurationsResult {
#[serde(rename = "S3Logs")]
pub s3_logs: OrganizationS3LogsConfigurationResult,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct OrganizationS3LogsConfiguration {
#[serde(rename = "AutoEnable")]
pub auto_enable: bool,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct OrganizationS3LogsConfigurationResult {
#[serde(rename = "AutoEnable")]
pub auto_enable: bool,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Owner {
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PermissionConfiguration {
#[serde(rename = "AccountLevelPermissions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_level_permissions: Option<AccountLevelPermissions>,
#[serde(rename = "BucketLevelPermissions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bucket_level_permissions: Option<BucketLevelPermissions>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PortProbeAction {
#[serde(rename = "Blocked")]
#[serde(skip_serializing_if = "Option::is_none")]
pub blocked: Option<bool>,
#[serde(rename = "PortProbeDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port_probe_details: Option<Vec<PortProbeDetail>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PortProbeDetail {
#[serde(rename = "LocalIpDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub local_ip_details: Option<LocalIpDetails>,
#[serde(rename = "LocalPortDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub local_port_details: Option<LocalPortDetails>,
#[serde(rename = "RemoteIpDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remote_ip_details: Option<RemoteIpDetails>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PrivateIpAddressDetails {
#[serde(rename = "PrivateDnsName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub private_dns_name: Option<String>,
#[serde(rename = "PrivateIpAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub private_ip_address: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProductCode {
#[serde(rename = "Code")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code: Option<String>,
#[serde(rename = "ProductType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PublicAccess {
#[serde(rename = "EffectivePermission")]
#[serde(skip_serializing_if = "Option::is_none")]
pub effective_permission: Option<String>,
#[serde(rename = "PermissionConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub permission_configuration: Option<PermissionConfiguration>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RemoteIpDetails {
#[serde(rename = "City")]
#[serde(skip_serializing_if = "Option::is_none")]
pub city: Option<City>,
#[serde(rename = "Country")]
#[serde(skip_serializing_if = "Option::is_none")]
pub country: Option<Country>,
#[serde(rename = "GeoLocation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub geo_location: Option<GeoLocation>,
#[serde(rename = "IpAddressV4")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ip_address_v4: Option<String>,
#[serde(rename = "Organization")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization: Option<Organization>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RemotePortDetails {
#[serde(rename = "Port")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port: Option<i64>,
#[serde(rename = "PortName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub port_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Resource {
#[serde(rename = "AccessKeyDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_key_details: Option<AccessKeyDetails>,
#[serde(rename = "InstanceDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub instance_details: Option<InstanceDetails>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "S3BucketDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_bucket_details: Option<Vec<S3BucketDetail>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct S3BucketDetail {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreatedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_at: Option<f64>,
#[serde(rename = "DefaultServerSideEncryption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_server_side_encryption: Option<DefaultServerSideEncryption>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Owner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner: Option<Owner>,
#[serde(rename = "PublicAccess")]
#[serde(skip_serializing_if = "Option::is_none")]
pub public_access: Option<PublicAccess>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct S3LogsConfiguration {
#[serde(rename = "Enable")]
pub enable: bool,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct S3LogsConfigurationResult {
#[serde(rename = "Status")]
pub status: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SecurityGroup {
#[serde(rename = "GroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_id: Option<String>,
#[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 Service {
#[serde(rename = "Action")]
#[serde(skip_serializing_if = "Option::is_none")]
pub action: Option<Action>,
#[serde(rename = "Archived")]
#[serde(skip_serializing_if = "Option::is_none")]
pub archived: Option<bool>,
#[serde(rename = "Count")]
#[serde(skip_serializing_if = "Option::is_none")]
pub count: Option<i64>,
#[serde(rename = "DetectorId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub detector_id: Option<String>,
#[serde(rename = "EventFirstSeen")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_first_seen: Option<String>,
#[serde(rename = "EventLastSeen")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_last_seen: Option<String>,
#[serde(rename = "Evidence")]
#[serde(skip_serializing_if = "Option::is_none")]
pub evidence: Option<Evidence>,
#[serde(rename = "ResourceRole")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_role: Option<String>,
#[serde(rename = "ServiceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_name: Option<String>,
#[serde(rename = "UserFeedback")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_feedback: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SortCriteria {
#[serde(rename = "AttributeName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attribute_name: Option<String>,
#[serde(rename = "OrderBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub order_by: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartMonitoringMembersRequest {
#[serde(rename = "AccountIds")]
pub account_ids: Vec<String>,
#[serde(rename = "DetectorId")]
pub detector_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartMonitoringMembersResponse {
#[serde(rename = "UnprocessedAccounts")]
pub unprocessed_accounts: Vec<UnprocessedAccount>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopMonitoringMembersRequest {
#[serde(rename = "AccountIds")]
pub account_ids: Vec<String>,
#[serde(rename = "DetectorId")]
pub detector_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StopMonitoringMembersResponse {
#[serde(rename = "UnprocessedAccounts")]
pub unprocessed_accounts: Vec<UnprocessedAccount>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(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: ::std::collections::HashMap<String, String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TagResourceResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ThreatIntelligenceDetail {
#[serde(rename = "ThreatListName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub threat_list_name: Option<String>,
#[serde(rename = "ThreatNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub threat_names: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Total {
#[serde(rename = "Amount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub amount: Option<String>,
#[serde(rename = "Unit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unit: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UnarchiveFindingsRequest {
#[serde(rename = "DetectorId")]
pub detector_id: String,
#[serde(rename = "FindingIds")]
pub finding_ids: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UnarchiveFindingsResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UnprocessedAccount {
#[serde(rename = "AccountId")]
pub account_id: String,
#[serde(rename = "Result")]
pub result: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UntagResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateDetectorRequest {
#[serde(rename = "DataSources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_sources: Option<DataSourceConfigurations>,
#[serde(rename = "DetectorId")]
pub detector_id: String,
#[serde(rename = "Enable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable: Option<bool>,
#[serde(rename = "FindingPublishingFrequency")]
#[serde(skip_serializing_if = "Option::is_none")]
pub finding_publishing_frequency: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateDetectorResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateFilterRequest {
#[serde(rename = "Action")]
#[serde(skip_serializing_if = "Option::is_none")]
pub action: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DetectorId")]
pub detector_id: String,
#[serde(rename = "FilterName")]
pub filter_name: String,
#[serde(rename = "FindingCriteria")]
#[serde(skip_serializing_if = "Option::is_none")]
pub finding_criteria: Option<FindingCriteria>,
#[serde(rename = "Rank")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rank: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateFilterResponse {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateFindingsFeedbackRequest {
#[serde(rename = "Comments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comments: Option<String>,
#[serde(rename = "DetectorId")]
pub detector_id: String,
#[serde(rename = "Feedback")]
pub feedback: String,
#[serde(rename = "FindingIds")]
pub finding_ids: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateFindingsFeedbackResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateIPSetRequest {
#[serde(rename = "Activate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub activate: Option<bool>,
#[serde(rename = "DetectorId")]
pub detector_id: String,
#[serde(rename = "IpSetId")]
pub ip_set_id: String,
#[serde(rename = "Location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateIPSetResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateMemberDetectorsRequest {
#[serde(rename = "AccountIds")]
pub account_ids: Vec<String>,
#[serde(rename = "DataSources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_sources: Option<DataSourceConfigurations>,
#[serde(rename = "DetectorId")]
pub detector_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateMemberDetectorsResponse {
#[serde(rename = "UnprocessedAccounts")]
pub unprocessed_accounts: Vec<UnprocessedAccount>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateOrganizationConfigurationRequest {
#[serde(rename = "AutoEnable")]
pub auto_enable: bool,
#[serde(rename = "DataSources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_sources: Option<OrganizationDataSourceConfigurations>,
#[serde(rename = "DetectorId")]
pub detector_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateOrganizationConfigurationResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdatePublishingDestinationRequest {
#[serde(rename = "DestinationId")]
pub destination_id: String,
#[serde(rename = "DestinationProperties")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_properties: Option<DestinationProperties>,
#[serde(rename = "DetectorId")]
pub detector_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdatePublishingDestinationResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateThreatIntelSetRequest {
#[serde(rename = "Activate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub activate: Option<bool>,
#[serde(rename = "DetectorId")]
pub detector_id: String,
#[serde(rename = "Location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ThreatIntelSetId")]
pub threat_intel_set_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateThreatIntelSetResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UsageAccountResult {
#[serde(rename = "AccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_id: Option<String>,
#[serde(rename = "Total")]
#[serde(skip_serializing_if = "Option::is_none")]
pub total: Option<Total>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UsageCriteria {
#[serde(rename = "AccountIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_ids: Option<Vec<String>>,
#[serde(rename = "DataSources")]
pub data_sources: Vec<String>,
#[serde(rename = "Resources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resources: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UsageDataSourceResult {
#[serde(rename = "DataSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_source: Option<String>,
#[serde(rename = "Total")]
#[serde(skip_serializing_if = "Option::is_none")]
pub total: Option<Total>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UsageResourceResult {
#[serde(rename = "Resource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource: Option<String>,
#[serde(rename = "Total")]
#[serde(skip_serializing_if = "Option::is_none")]
pub total: Option<Total>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UsageStatistics {
#[serde(rename = "SumByAccount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sum_by_account: Option<Vec<UsageAccountResult>>,
#[serde(rename = "SumByDataSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sum_by_data_source: Option<Vec<UsageDataSourceResult>>,
#[serde(rename = "SumByResource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sum_by_resource: Option<Vec<UsageResourceResult>>,
#[serde(rename = "TopResources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub top_resources: Option<Vec<UsageResourceResult>>,
}
#[derive(Debug, PartialEq)]
pub enum AcceptInvitationError {
BadRequest(String),
InternalServerError(String),
}
impl AcceptInvitationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AcceptInvitationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(AcceptInvitationError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(AcceptInvitationError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AcceptInvitationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AcceptInvitationError::BadRequest(ref cause) => write!(f, "{}", cause),
AcceptInvitationError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AcceptInvitationError {}
#[derive(Debug, PartialEq)]
pub enum ArchiveFindingsError {
BadRequest(String),
InternalServerError(String),
}
impl ArchiveFindingsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ArchiveFindingsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ArchiveFindingsError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(ArchiveFindingsError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ArchiveFindingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ArchiveFindingsError::BadRequest(ref cause) => write!(f, "{}", cause),
ArchiveFindingsError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ArchiveFindingsError {}
#[derive(Debug, PartialEq)]
pub enum CreateDetectorError {
BadRequest(String),
InternalServerError(String),
}
impl CreateDetectorError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDetectorError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateDetectorError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(CreateDetectorError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDetectorError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDetectorError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateDetectorError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDetectorError {}
#[derive(Debug, PartialEq)]
pub enum CreateFilterError {
BadRequest(String),
InternalServerError(String),
}
impl CreateFilterError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateFilterError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateFilterError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(CreateFilterError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateFilterError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateFilterError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateFilterError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateFilterError {}
#[derive(Debug, PartialEq)]
pub enum CreateIPSetError {
BadRequest(String),
InternalServerError(String),
}
impl CreateIPSetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateIPSetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateIPSetError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(CreateIPSetError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateIPSetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateIPSetError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateIPSetError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateIPSetError {}
#[derive(Debug, PartialEq)]
pub enum CreateMembersError {
BadRequest(String),
InternalServerError(String),
}
impl CreateMembersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateMembersError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateMembersError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(CreateMembersError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateMembersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateMembersError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateMembersError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateMembersError {}
#[derive(Debug, PartialEq)]
pub enum CreatePublishingDestinationError {
BadRequest(String),
InternalServerError(String),
}
impl CreatePublishingDestinationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreatePublishingDestinationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreatePublishingDestinationError::BadRequest(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
CreatePublishingDestinationError::InternalServerError(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreatePublishingDestinationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreatePublishingDestinationError::BadRequest(ref cause) => write!(f, "{}", cause),
CreatePublishingDestinationError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreatePublishingDestinationError {}
#[derive(Debug, PartialEq)]
pub enum CreateSampleFindingsError {
BadRequest(String),
InternalServerError(String),
}
impl CreateSampleFindingsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateSampleFindingsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateSampleFindingsError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(CreateSampleFindingsError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateSampleFindingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateSampleFindingsError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateSampleFindingsError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateSampleFindingsError {}
#[derive(Debug, PartialEq)]
pub enum CreateThreatIntelSetError {
BadRequest(String),
InternalServerError(String),
}
impl CreateThreatIntelSetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateThreatIntelSetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateThreatIntelSetError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(CreateThreatIntelSetError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateThreatIntelSetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateThreatIntelSetError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateThreatIntelSetError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateThreatIntelSetError {}
#[derive(Debug, PartialEq)]
pub enum DeclineInvitationsError {
BadRequest(String),
InternalServerError(String),
}
impl DeclineInvitationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeclineInvitationsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeclineInvitationsError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(DeclineInvitationsError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeclineInvitationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeclineInvitationsError::BadRequest(ref cause) => write!(f, "{}", cause),
DeclineInvitationsError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeclineInvitationsError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDetectorError {
BadRequest(String),
InternalServerError(String),
}
impl DeleteDetectorError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDetectorError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteDetectorError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(DeleteDetectorError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDetectorError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDetectorError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteDetectorError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDetectorError {}
#[derive(Debug, PartialEq)]
pub enum DeleteFilterError {
BadRequest(String),
InternalServerError(String),
}
impl DeleteFilterError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteFilterError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteFilterError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(DeleteFilterError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteFilterError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteFilterError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteFilterError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteFilterError {}
#[derive(Debug, PartialEq)]
pub enum DeleteIPSetError {
BadRequest(String),
InternalServerError(String),
}
impl DeleteIPSetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteIPSetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteIPSetError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(DeleteIPSetError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteIPSetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteIPSetError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteIPSetError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteIPSetError {}
#[derive(Debug, PartialEq)]
pub enum DeleteInvitationsError {
BadRequest(String),
InternalServerError(String),
}
impl DeleteInvitationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteInvitationsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteInvitationsError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(DeleteInvitationsError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteInvitationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteInvitationsError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteInvitationsError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteInvitationsError {}
#[derive(Debug, PartialEq)]
pub enum DeleteMembersError {
BadRequest(String),
InternalServerError(String),
}
impl DeleteMembersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteMembersError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteMembersError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(DeleteMembersError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteMembersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteMembersError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteMembersError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteMembersError {}
#[derive(Debug, PartialEq)]
pub enum DeletePublishingDestinationError {
BadRequest(String),
InternalServerError(String),
}
impl DeletePublishingDestinationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeletePublishingDestinationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeletePublishingDestinationError::BadRequest(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
DeletePublishingDestinationError::InternalServerError(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeletePublishingDestinationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeletePublishingDestinationError::BadRequest(ref cause) => write!(f, "{}", cause),
DeletePublishingDestinationError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeletePublishingDestinationError {}
#[derive(Debug, PartialEq)]
pub enum DeleteThreatIntelSetError {
BadRequest(String),
InternalServerError(String),
}
impl DeleteThreatIntelSetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteThreatIntelSetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteThreatIntelSetError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(DeleteThreatIntelSetError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteThreatIntelSetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteThreatIntelSetError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteThreatIntelSetError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteThreatIntelSetError {}
#[derive(Debug, PartialEq)]
pub enum DescribeOrganizationConfigurationError {
BadRequest(String),
InternalServerError(String),
}
impl DescribeOrganizationConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeOrganizationConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(
DescribeOrganizationConfigurationError::BadRequest(err.msg),
)
}
"InternalServerErrorException" => {
return RusotoError::Service(
DescribeOrganizationConfigurationError::InternalServerError(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeOrganizationConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeOrganizationConfigurationError::BadRequest(ref cause) => write!(f, "{}", cause),
DescribeOrganizationConfigurationError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeOrganizationConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum DescribePublishingDestinationError {
BadRequest(String),
InternalServerError(String),
}
impl DescribePublishingDestinationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribePublishingDestinationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DescribePublishingDestinationError::BadRequest(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
DescribePublishingDestinationError::InternalServerError(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribePublishingDestinationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribePublishingDestinationError::BadRequest(ref cause) => write!(f, "{}", cause),
DescribePublishingDestinationError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribePublishingDestinationError {}
#[derive(Debug, PartialEq)]
pub enum DisableOrganizationAdminAccountError {
BadRequest(String),
InternalServerError(String),
}
impl DisableOrganizationAdminAccountError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisableOrganizationAdminAccountError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DisableOrganizationAdminAccountError::BadRequest(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
DisableOrganizationAdminAccountError::InternalServerError(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisableOrganizationAdminAccountError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisableOrganizationAdminAccountError::BadRequest(ref cause) => write!(f, "{}", cause),
DisableOrganizationAdminAccountError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DisableOrganizationAdminAccountError {}
#[derive(Debug, PartialEq)]
pub enum DisassociateFromMasterAccountError {
BadRequest(String),
InternalServerError(String),
}
impl DisassociateFromMasterAccountError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisassociateFromMasterAccountError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DisassociateFromMasterAccountError::BadRequest(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
DisassociateFromMasterAccountError::InternalServerError(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisassociateFromMasterAccountError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisassociateFromMasterAccountError::BadRequest(ref cause) => write!(f, "{}", cause),
DisassociateFromMasterAccountError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DisassociateFromMasterAccountError {}
#[derive(Debug, PartialEq)]
pub enum DisassociateMembersError {
BadRequest(String),
InternalServerError(String),
}
impl DisassociateMembersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DisassociateMembersError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DisassociateMembersError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(DisassociateMembersError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisassociateMembersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisassociateMembersError::BadRequest(ref cause) => write!(f, "{}", cause),
DisassociateMembersError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DisassociateMembersError {}
#[derive(Debug, PartialEq)]
pub enum EnableOrganizationAdminAccountError {
BadRequest(String),
InternalServerError(String),
}
impl EnableOrganizationAdminAccountError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<EnableOrganizationAdminAccountError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(EnableOrganizationAdminAccountError::BadRequest(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
EnableOrganizationAdminAccountError::InternalServerError(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for EnableOrganizationAdminAccountError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
EnableOrganizationAdminAccountError::BadRequest(ref cause) => write!(f, "{}", cause),
EnableOrganizationAdminAccountError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for EnableOrganizationAdminAccountError {}
#[derive(Debug, PartialEq)]
pub enum GetDetectorError {
BadRequest(String),
InternalServerError(String),
}
impl GetDetectorError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDetectorError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetDetectorError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(GetDetectorError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDetectorError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDetectorError::BadRequest(ref cause) => write!(f, "{}", cause),
GetDetectorError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDetectorError {}
#[derive(Debug, PartialEq)]
pub enum GetFilterError {
BadRequest(String),
InternalServerError(String),
}
impl GetFilterError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetFilterError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetFilterError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(GetFilterError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetFilterError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetFilterError::BadRequest(ref cause) => write!(f, "{}", cause),
GetFilterError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetFilterError {}
#[derive(Debug, PartialEq)]
pub enum GetFindingsError {
BadRequest(String),
InternalServerError(String),
}
impl GetFindingsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetFindingsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetFindingsError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(GetFindingsError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetFindingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetFindingsError::BadRequest(ref cause) => write!(f, "{}", cause),
GetFindingsError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetFindingsError {}
#[derive(Debug, PartialEq)]
pub enum GetFindingsStatisticsError {
BadRequest(String),
InternalServerError(String),
}
impl GetFindingsStatisticsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetFindingsStatisticsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetFindingsStatisticsError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(GetFindingsStatisticsError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetFindingsStatisticsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetFindingsStatisticsError::BadRequest(ref cause) => write!(f, "{}", cause),
GetFindingsStatisticsError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetFindingsStatisticsError {}
#[derive(Debug, PartialEq)]
pub enum GetIPSetError {
BadRequest(String),
InternalServerError(String),
}
impl GetIPSetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetIPSetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetIPSetError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(GetIPSetError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetIPSetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetIPSetError::BadRequest(ref cause) => write!(f, "{}", cause),
GetIPSetError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetIPSetError {}
#[derive(Debug, PartialEq)]
pub enum GetInvitationsCountError {
BadRequest(String),
InternalServerError(String),
}
impl GetInvitationsCountError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetInvitationsCountError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetInvitationsCountError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(GetInvitationsCountError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetInvitationsCountError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetInvitationsCountError::BadRequest(ref cause) => write!(f, "{}", cause),
GetInvitationsCountError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetInvitationsCountError {}
#[derive(Debug, PartialEq)]
pub enum GetMasterAccountError {
BadRequest(String),
InternalServerError(String),
}
impl GetMasterAccountError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetMasterAccountError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetMasterAccountError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(GetMasterAccountError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetMasterAccountError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetMasterAccountError::BadRequest(ref cause) => write!(f, "{}", cause),
GetMasterAccountError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetMasterAccountError {}
#[derive(Debug, PartialEq)]
pub enum GetMemberDetectorsError {
BadRequest(String),
InternalServerError(String),
}
impl GetMemberDetectorsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetMemberDetectorsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetMemberDetectorsError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(GetMemberDetectorsError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetMemberDetectorsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetMemberDetectorsError::BadRequest(ref cause) => write!(f, "{}", cause),
GetMemberDetectorsError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetMemberDetectorsError {}
#[derive(Debug, PartialEq)]
pub enum GetMembersError {
BadRequest(String),
InternalServerError(String),
}
impl GetMembersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetMembersError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetMembersError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(GetMembersError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetMembersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetMembersError::BadRequest(ref cause) => write!(f, "{}", cause),
GetMembersError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetMembersError {}
#[derive(Debug, PartialEq)]
pub enum GetThreatIntelSetError {
BadRequest(String),
InternalServerError(String),
}
impl GetThreatIntelSetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetThreatIntelSetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetThreatIntelSetError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(GetThreatIntelSetError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetThreatIntelSetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetThreatIntelSetError::BadRequest(ref cause) => write!(f, "{}", cause),
GetThreatIntelSetError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetThreatIntelSetError {}
#[derive(Debug, PartialEq)]
pub enum GetUsageStatisticsError {
BadRequest(String),
InternalServerError(String),
}
impl GetUsageStatisticsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetUsageStatisticsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetUsageStatisticsError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(GetUsageStatisticsError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetUsageStatisticsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetUsageStatisticsError::BadRequest(ref cause) => write!(f, "{}", cause),
GetUsageStatisticsError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetUsageStatisticsError {}
#[derive(Debug, PartialEq)]
pub enum InviteMembersError {
BadRequest(String),
InternalServerError(String),
}
impl InviteMembersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<InviteMembersError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(InviteMembersError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(InviteMembersError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for InviteMembersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
InviteMembersError::BadRequest(ref cause) => write!(f, "{}", cause),
InviteMembersError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for InviteMembersError {}
#[derive(Debug, PartialEq)]
pub enum ListDetectorsError {
BadRequest(String),
InternalServerError(String),
}
impl ListDetectorsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDetectorsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListDetectorsError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(ListDetectorsError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDetectorsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDetectorsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListDetectorsError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDetectorsError {}
#[derive(Debug, PartialEq)]
pub enum ListFiltersError {
BadRequest(String),
InternalServerError(String),
}
impl ListFiltersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListFiltersError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListFiltersError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(ListFiltersError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListFiltersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListFiltersError::BadRequest(ref cause) => write!(f, "{}", cause),
ListFiltersError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListFiltersError {}
#[derive(Debug, PartialEq)]
pub enum ListFindingsError {
BadRequest(String),
InternalServerError(String),
}
impl ListFindingsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListFindingsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListFindingsError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(ListFindingsError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListFindingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListFindingsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListFindingsError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListFindingsError {}
#[derive(Debug, PartialEq)]
pub enum ListIPSetsError {
BadRequest(String),
InternalServerError(String),
}
impl ListIPSetsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListIPSetsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListIPSetsError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(ListIPSetsError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListIPSetsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListIPSetsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListIPSetsError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListIPSetsError {}
#[derive(Debug, PartialEq)]
pub enum ListInvitationsError {
BadRequest(String),
InternalServerError(String),
}
impl ListInvitationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListInvitationsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListInvitationsError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(ListInvitationsError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListInvitationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListInvitationsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListInvitationsError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListInvitationsError {}
#[derive(Debug, PartialEq)]
pub enum ListMembersError {
BadRequest(String),
InternalServerError(String),
}
impl ListMembersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListMembersError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListMembersError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(ListMembersError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListMembersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListMembersError::BadRequest(ref cause) => write!(f, "{}", cause),
ListMembersError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListMembersError {}
#[derive(Debug, PartialEq)]
pub enum ListOrganizationAdminAccountsError {
BadRequest(String),
InternalServerError(String),
}
impl ListOrganizationAdminAccountsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListOrganizationAdminAccountsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListOrganizationAdminAccountsError::BadRequest(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
ListOrganizationAdminAccountsError::InternalServerError(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListOrganizationAdminAccountsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListOrganizationAdminAccountsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListOrganizationAdminAccountsError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListOrganizationAdminAccountsError {}
#[derive(Debug, PartialEq)]
pub enum ListPublishingDestinationsError {
BadRequest(String),
InternalServerError(String),
}
impl ListPublishingDestinationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListPublishingDestinationsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListPublishingDestinationsError::BadRequest(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
ListPublishingDestinationsError::InternalServerError(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListPublishingDestinationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListPublishingDestinationsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListPublishingDestinationsError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListPublishingDestinationsError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
BadRequest(String),
InternalServerError(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListTagsForResourceError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(ListTagsForResourceError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsForResourceError::BadRequest(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum ListThreatIntelSetsError {
BadRequest(String),
InternalServerError(String),
}
impl ListThreatIntelSetsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListThreatIntelSetsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListThreatIntelSetsError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(ListThreatIntelSetsError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListThreatIntelSetsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListThreatIntelSetsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListThreatIntelSetsError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListThreatIntelSetsError {}
#[derive(Debug, PartialEq)]
pub enum StartMonitoringMembersError {
BadRequest(String),
InternalServerError(String),
}
impl StartMonitoringMembersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartMonitoringMembersError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(StartMonitoringMembersError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(StartMonitoringMembersError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartMonitoringMembersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartMonitoringMembersError::BadRequest(ref cause) => write!(f, "{}", cause),
StartMonitoringMembersError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartMonitoringMembersError {}
#[derive(Debug, PartialEq)]
pub enum StopMonitoringMembersError {
BadRequest(String),
InternalServerError(String),
}
impl StopMonitoringMembersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopMonitoringMembersError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(StopMonitoringMembersError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(StopMonitoringMembersError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StopMonitoringMembersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StopMonitoringMembersError::BadRequest(ref cause) => write!(f, "{}", cause),
StopMonitoringMembersError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StopMonitoringMembersError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
BadRequest(String),
InternalServerError(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(TagResourceError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(TagResourceError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagResourceError::BadRequest(ref cause) => write!(f, "{}", cause),
TagResourceError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UnarchiveFindingsError {
BadRequest(String),
InternalServerError(String),
}
impl UnarchiveFindingsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UnarchiveFindingsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UnarchiveFindingsError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(UnarchiveFindingsError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UnarchiveFindingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UnarchiveFindingsError::BadRequest(ref cause) => write!(f, "{}", cause),
UnarchiveFindingsError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UnarchiveFindingsError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
BadRequest(String),
InternalServerError(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UntagResourceError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(UntagResourceError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UntagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UntagResourceError::BadRequest(ref cause) => write!(f, "{}", cause),
UntagResourceError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateDetectorError {
BadRequest(String),
InternalServerError(String),
}
impl UpdateDetectorError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateDetectorError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateDetectorError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(UpdateDetectorError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateDetectorError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateDetectorError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateDetectorError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateDetectorError {}
#[derive(Debug, PartialEq)]
pub enum UpdateFilterError {
BadRequest(String),
InternalServerError(String),
}
impl UpdateFilterError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateFilterError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateFilterError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(UpdateFilterError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateFilterError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateFilterError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateFilterError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateFilterError {}
#[derive(Debug, PartialEq)]
pub enum UpdateFindingsFeedbackError {
BadRequest(String),
InternalServerError(String),
}
impl UpdateFindingsFeedbackError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateFindingsFeedbackError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateFindingsFeedbackError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(UpdateFindingsFeedbackError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateFindingsFeedbackError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateFindingsFeedbackError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateFindingsFeedbackError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateFindingsFeedbackError {}
#[derive(Debug, PartialEq)]
pub enum UpdateIPSetError {
BadRequest(String),
InternalServerError(String),
}
impl UpdateIPSetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateIPSetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateIPSetError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(UpdateIPSetError::InternalServerError(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateIPSetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateIPSetError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateIPSetError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateIPSetError {}
#[derive(Debug, PartialEq)]
pub enum UpdateMemberDetectorsError {
BadRequest(String),
InternalServerError(String),
}
impl UpdateMemberDetectorsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateMemberDetectorsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateMemberDetectorsError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(UpdateMemberDetectorsError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateMemberDetectorsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateMemberDetectorsError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateMemberDetectorsError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateMemberDetectorsError {}
#[derive(Debug, PartialEq)]
pub enum UpdateOrganizationConfigurationError {
BadRequest(String),
InternalServerError(String),
}
impl UpdateOrganizationConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateOrganizationConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateOrganizationConfigurationError::BadRequest(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
UpdateOrganizationConfigurationError::InternalServerError(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateOrganizationConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateOrganizationConfigurationError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateOrganizationConfigurationError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateOrganizationConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum UpdatePublishingDestinationError {
BadRequest(String),
InternalServerError(String),
}
impl UpdatePublishingDestinationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdatePublishingDestinationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdatePublishingDestinationError::BadRequest(
err.msg,
))
}
"InternalServerErrorException" => {
return RusotoError::Service(
UpdatePublishingDestinationError::InternalServerError(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdatePublishingDestinationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdatePublishingDestinationError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdatePublishingDestinationError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdatePublishingDestinationError {}
#[derive(Debug, PartialEq)]
pub enum UpdateThreatIntelSetError {
BadRequest(String),
InternalServerError(String),
}
impl UpdateThreatIntelSetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateThreatIntelSetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateThreatIntelSetError::BadRequest(err.msg))
}
"InternalServerErrorException" => {
return RusotoError::Service(UpdateThreatIntelSetError::InternalServerError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateThreatIntelSetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateThreatIntelSetError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateThreatIntelSetError::InternalServerError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateThreatIntelSetError {}
#[async_trait]
pub trait GuardDuty {
async fn accept_invitation(
&self,
input: AcceptInvitationRequest,
) -> Result<AcceptInvitationResponse, RusotoError<AcceptInvitationError>>;
async fn archive_findings(
&self,
input: ArchiveFindingsRequest,
) -> Result<ArchiveFindingsResponse, RusotoError<ArchiveFindingsError>>;
async fn create_detector(
&self,
input: CreateDetectorRequest,
) -> Result<CreateDetectorResponse, RusotoError<CreateDetectorError>>;
async fn create_filter(
&self,
input: CreateFilterRequest,
) -> Result<CreateFilterResponse, RusotoError<CreateFilterError>>;
async fn create_ip_set(
&self,
input: CreateIPSetRequest,
) -> Result<CreateIPSetResponse, RusotoError<CreateIPSetError>>;
async fn create_members(
&self,
input: CreateMembersRequest,
) -> Result<CreateMembersResponse, RusotoError<CreateMembersError>>;
async fn create_publishing_destination(
&self,
input: CreatePublishingDestinationRequest,
) -> Result<CreatePublishingDestinationResponse, RusotoError<CreatePublishingDestinationError>>;
async fn create_sample_findings(
&self,
input: CreateSampleFindingsRequest,
) -> Result<CreateSampleFindingsResponse, RusotoError<CreateSampleFindingsError>>;
async fn create_threat_intel_set(
&self,
input: CreateThreatIntelSetRequest,
) -> Result<CreateThreatIntelSetResponse, RusotoError<CreateThreatIntelSetError>>;
async fn decline_invitations(
&self,
input: DeclineInvitationsRequest,
) -> Result<DeclineInvitationsResponse, RusotoError<DeclineInvitationsError>>;
async fn delete_detector(
&self,
input: DeleteDetectorRequest,
) -> Result<DeleteDetectorResponse, RusotoError<DeleteDetectorError>>;
async fn delete_filter(
&self,
input: DeleteFilterRequest,
) -> Result<DeleteFilterResponse, RusotoError<DeleteFilterError>>;
async fn delete_ip_set(
&self,
input: DeleteIPSetRequest,
) -> Result<DeleteIPSetResponse, RusotoError<DeleteIPSetError>>;
async fn delete_invitations(
&self,
input: DeleteInvitationsRequest,
) -> Result<DeleteInvitationsResponse, RusotoError<DeleteInvitationsError>>;
async fn delete_members(
&self,
input: DeleteMembersRequest,
) -> Result<DeleteMembersResponse, RusotoError<DeleteMembersError>>;
async fn delete_publishing_destination(
&self,
input: DeletePublishingDestinationRequest,
) -> Result<DeletePublishingDestinationResponse, RusotoError<DeletePublishingDestinationError>>;
async fn delete_threat_intel_set(
&self,
input: DeleteThreatIntelSetRequest,
) -> Result<DeleteThreatIntelSetResponse, RusotoError<DeleteThreatIntelSetError>>;
async fn describe_organization_configuration(
&self,
input: DescribeOrganizationConfigurationRequest,
) -> Result<
DescribeOrganizationConfigurationResponse,
RusotoError<DescribeOrganizationConfigurationError>,
>;
async fn describe_publishing_destination(
&self,
input: DescribePublishingDestinationRequest,
) -> Result<
DescribePublishingDestinationResponse,
RusotoError<DescribePublishingDestinationError>,
>;
async fn disable_organization_admin_account(
&self,
input: DisableOrganizationAdminAccountRequest,
) -> Result<
DisableOrganizationAdminAccountResponse,
RusotoError<DisableOrganizationAdminAccountError>,
>;
async fn disassociate_from_master_account(
&self,
input: DisassociateFromMasterAccountRequest,
) -> Result<
DisassociateFromMasterAccountResponse,
RusotoError<DisassociateFromMasterAccountError>,
>;
async fn disassociate_members(
&self,
input: DisassociateMembersRequest,
) -> Result<DisassociateMembersResponse, RusotoError<DisassociateMembersError>>;
async fn enable_organization_admin_account(
&self,
input: EnableOrganizationAdminAccountRequest,
) -> Result<
EnableOrganizationAdminAccountResponse,
RusotoError<EnableOrganizationAdminAccountError>,
>;
async fn get_detector(
&self,
input: GetDetectorRequest,
) -> Result<GetDetectorResponse, RusotoError<GetDetectorError>>;
async fn get_filter(
&self,
input: GetFilterRequest,
) -> Result<GetFilterResponse, RusotoError<GetFilterError>>;
async fn get_findings(
&self,
input: GetFindingsRequest,
) -> Result<GetFindingsResponse, RusotoError<GetFindingsError>>;
async fn get_findings_statistics(
&self,
input: GetFindingsStatisticsRequest,
) -> Result<GetFindingsStatisticsResponse, RusotoError<GetFindingsStatisticsError>>;
async fn get_ip_set(
&self,
input: GetIPSetRequest,
) -> Result<GetIPSetResponse, RusotoError<GetIPSetError>>;
async fn get_invitations_count(
&self,
) -> Result<GetInvitationsCountResponse, RusotoError<GetInvitationsCountError>>;
async fn get_master_account(
&self,
input: GetMasterAccountRequest,
) -> Result<GetMasterAccountResponse, RusotoError<GetMasterAccountError>>;
async fn get_member_detectors(
&self,
input: GetMemberDetectorsRequest,
) -> Result<GetMemberDetectorsResponse, RusotoError<GetMemberDetectorsError>>;
async fn get_members(
&self,
input: GetMembersRequest,
) -> Result<GetMembersResponse, RusotoError<GetMembersError>>;
async fn get_threat_intel_set(
&self,
input: GetThreatIntelSetRequest,
) -> Result<GetThreatIntelSetResponse, RusotoError<GetThreatIntelSetError>>;
async fn get_usage_statistics(
&self,
input: GetUsageStatisticsRequest,
) -> Result<GetUsageStatisticsResponse, RusotoError<GetUsageStatisticsError>>;
async fn invite_members(
&self,
input: InviteMembersRequest,
) -> Result<InviteMembersResponse, RusotoError<InviteMembersError>>;
async fn list_detectors(
&self,
input: ListDetectorsRequest,
) -> Result<ListDetectorsResponse, RusotoError<ListDetectorsError>>;
async fn list_filters(
&self,
input: ListFiltersRequest,
) -> Result<ListFiltersResponse, RusotoError<ListFiltersError>>;
async fn list_findings(
&self,
input: ListFindingsRequest,
) -> Result<ListFindingsResponse, RusotoError<ListFindingsError>>;
async fn list_ip_sets(
&self,
input: ListIPSetsRequest,
) -> Result<ListIPSetsResponse, RusotoError<ListIPSetsError>>;
async fn list_invitations(
&self,
input: ListInvitationsRequest,
) -> Result<ListInvitationsResponse, RusotoError<ListInvitationsError>>;
async fn list_members(
&self,
input: ListMembersRequest,
) -> Result<ListMembersResponse, RusotoError<ListMembersError>>;
async fn list_organization_admin_accounts(
&self,
input: ListOrganizationAdminAccountsRequest,
) -> Result<
ListOrganizationAdminAccountsResponse,
RusotoError<ListOrganizationAdminAccountsError>,
>;
async fn list_publishing_destinations(
&self,
input: ListPublishingDestinationsRequest,
) -> Result<ListPublishingDestinationsResponse, RusotoError<ListPublishingDestinationsError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
async fn list_threat_intel_sets(
&self,
input: ListThreatIntelSetsRequest,
) -> Result<ListThreatIntelSetsResponse, RusotoError<ListThreatIntelSetsError>>;
async fn start_monitoring_members(
&self,
input: StartMonitoringMembersRequest,
) -> Result<StartMonitoringMembersResponse, RusotoError<StartMonitoringMembersError>>;
async fn stop_monitoring_members(
&self,
input: StopMonitoringMembersRequest,
) -> Result<StopMonitoringMembersResponse, RusotoError<StopMonitoringMembersError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>>;
async fn unarchive_findings(
&self,
input: UnarchiveFindingsRequest,
) -> Result<UnarchiveFindingsResponse, RusotoError<UnarchiveFindingsError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>>;
async fn update_detector(
&self,
input: UpdateDetectorRequest,
) -> Result<UpdateDetectorResponse, RusotoError<UpdateDetectorError>>;
async fn update_filter(
&self,
input: UpdateFilterRequest,
) -> Result<UpdateFilterResponse, RusotoError<UpdateFilterError>>;
async fn update_findings_feedback(
&self,
input: UpdateFindingsFeedbackRequest,
) -> Result<UpdateFindingsFeedbackResponse, RusotoError<UpdateFindingsFeedbackError>>;
async fn update_ip_set(
&self,
input: UpdateIPSetRequest,
) -> Result<UpdateIPSetResponse, RusotoError<UpdateIPSetError>>;
async fn update_member_detectors(
&self,
input: UpdateMemberDetectorsRequest,
) -> Result<UpdateMemberDetectorsResponse, RusotoError<UpdateMemberDetectorsError>>;
async fn update_organization_configuration(
&self,
input: UpdateOrganizationConfigurationRequest,
) -> Result<
UpdateOrganizationConfigurationResponse,
RusotoError<UpdateOrganizationConfigurationError>,
>;
async fn update_publishing_destination(
&self,
input: UpdatePublishingDestinationRequest,
) -> Result<UpdatePublishingDestinationResponse, RusotoError<UpdatePublishingDestinationError>>;
async fn update_threat_intel_set(
&self,
input: UpdateThreatIntelSetRequest,
) -> Result<UpdateThreatIntelSetResponse, RusotoError<UpdateThreatIntelSetError>>;
}
#[derive(Clone)]
pub struct GuardDutyClient {
client: Client,
region: region::Region,
}
impl GuardDutyClient {
pub fn new(region: region::Region) -> GuardDutyClient {
GuardDutyClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> GuardDutyClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
GuardDutyClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> GuardDutyClient {
GuardDutyClient { client, region }
}
}
#[async_trait]
impl GuardDuty for GuardDutyClient {
#[allow(unused_mut)]
async fn accept_invitation(
&self,
input: AcceptInvitationRequest,
) -> Result<AcceptInvitationResponse, RusotoError<AcceptInvitationError>> {
let request_uri = format!(
"/detector/{detector_id}/master",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<AcceptInvitationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(AcceptInvitationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn archive_findings(
&self,
input: ArchiveFindingsRequest,
) -> Result<ArchiveFindingsResponse, RusotoError<ArchiveFindingsError>> {
let request_uri = format!(
"/detector/{detector_id}/findings/archive",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ArchiveFindingsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ArchiveFindingsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_detector(
&self,
input: CreateDetectorRequest,
) -> Result<CreateDetectorResponse, RusotoError<CreateDetectorError>> {
let request_uri = "/detector";
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateDetectorResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateDetectorError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_filter(
&self,
input: CreateFilterRequest,
) -> Result<CreateFilterResponse, RusotoError<CreateFilterError>> {
let request_uri = format!(
"/detector/{detector_id}/filter",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateFilterResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateFilterError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_ip_set(
&self,
input: CreateIPSetRequest,
) -> Result<CreateIPSetResponse, RusotoError<CreateIPSetError>> {
let request_uri = format!(
"/detector/{detector_id}/ipset",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateIPSetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateIPSetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_members(
&self,
input: CreateMembersRequest,
) -> Result<CreateMembersResponse, RusotoError<CreateMembersError>> {
let request_uri = format!(
"/detector/{detector_id}/member",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateMembersResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateMembersError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_publishing_destination(
&self,
input: CreatePublishingDestinationRequest,
) -> Result<CreatePublishingDestinationResponse, RusotoError<CreatePublishingDestinationError>>
{
let request_uri = format!(
"/detector/{detector_id}/publishingDestination",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreatePublishingDestinationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreatePublishingDestinationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_sample_findings(
&self,
input: CreateSampleFindingsRequest,
) -> Result<CreateSampleFindingsResponse, RusotoError<CreateSampleFindingsError>> {
let request_uri = format!(
"/detector/{detector_id}/findings/create",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateSampleFindingsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateSampleFindingsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_threat_intel_set(
&self,
input: CreateThreatIntelSetRequest,
) -> Result<CreateThreatIntelSetResponse, RusotoError<CreateThreatIntelSetError>> {
let request_uri = format!(
"/detector/{detector_id}/threatintelset",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateThreatIntelSetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateThreatIntelSetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn decline_invitations(
&self,
input: DeclineInvitationsRequest,
) -> Result<DeclineInvitationsResponse, RusotoError<DeclineInvitationsError>> {
let request_uri = "/invitation/decline";
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeclineInvitationsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeclineInvitationsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_detector(
&self,
input: DeleteDetectorRequest,
) -> Result<DeleteDetectorResponse, RusotoError<DeleteDetectorError>> {
let request_uri = format!("/detector/{detector_id}", detector_id = input.detector_id);
let mut request = SignedRequest::new("DELETE", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteDetectorResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteDetectorError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_filter(
&self,
input: DeleteFilterRequest,
) -> Result<DeleteFilterResponse, RusotoError<DeleteFilterError>> {
let request_uri = format!(
"/detector/{detector_id}/filter/{filter_name}",
detector_id = input.detector_id,
filter_name = input.filter_name
);
let mut request = SignedRequest::new("DELETE", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteFilterResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteFilterError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_ip_set(
&self,
input: DeleteIPSetRequest,
) -> Result<DeleteIPSetResponse, RusotoError<DeleteIPSetError>> {
let request_uri = format!(
"/detector/{detector_id}/ipset/{ip_set_id}",
detector_id = input.detector_id,
ip_set_id = input.ip_set_id
);
let mut request = SignedRequest::new("DELETE", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteIPSetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteIPSetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_invitations(
&self,
input: DeleteInvitationsRequest,
) -> Result<DeleteInvitationsResponse, RusotoError<DeleteInvitationsError>> {
let request_uri = "/invitation/delete";
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteInvitationsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteInvitationsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_members(
&self,
input: DeleteMembersRequest,
) -> Result<DeleteMembersResponse, RusotoError<DeleteMembersError>> {
let request_uri = format!(
"/detector/{detector_id}/member/delete",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteMembersResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteMembersError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_publishing_destination(
&self,
input: DeletePublishingDestinationRequest,
) -> Result<DeletePublishingDestinationResponse, RusotoError<DeletePublishingDestinationError>>
{
let request_uri = format!(
"/detector/{detector_id}/publishingDestination/{destination_id}",
destination_id = input.destination_id,
detector_id = input.detector_id
);
let mut request = SignedRequest::new("DELETE", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeletePublishingDestinationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeletePublishingDestinationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_threat_intel_set(
&self,
input: DeleteThreatIntelSetRequest,
) -> Result<DeleteThreatIntelSetResponse, RusotoError<DeleteThreatIntelSetError>> {
let request_uri = format!(
"/detector/{detector_id}/threatintelset/{threat_intel_set_id}",
detector_id = input.detector_id,
threat_intel_set_id = input.threat_intel_set_id
);
let mut request = SignedRequest::new("DELETE", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteThreatIntelSetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteThreatIntelSetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_organization_configuration(
&self,
input: DescribeOrganizationConfigurationRequest,
) -> Result<
DescribeOrganizationConfigurationResponse,
RusotoError<DescribeOrganizationConfigurationError>,
> {
let request_uri = format!(
"/detector/{detector_id}/admin",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("GET", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeOrganizationConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeOrganizationConfigurationError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn describe_publishing_destination(
&self,
input: DescribePublishingDestinationRequest,
) -> Result<
DescribePublishingDestinationResponse,
RusotoError<DescribePublishingDestinationError>,
> {
let request_uri = format!(
"/detector/{detector_id}/publishingDestination/{destination_id}",
destination_id = input.destination_id,
detector_id = input.detector_id
);
let mut request = SignedRequest::new("GET", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribePublishingDestinationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribePublishingDestinationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn disable_organization_admin_account(
&self,
input: DisableOrganizationAdminAccountRequest,
) -> Result<
DisableOrganizationAdminAccountResponse,
RusotoError<DisableOrganizationAdminAccountError>,
> {
let request_uri = "/admin/disable";
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DisableOrganizationAdminAccountResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DisableOrganizationAdminAccountError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn disassociate_from_master_account(
&self,
input: DisassociateFromMasterAccountRequest,
) -> Result<
DisassociateFromMasterAccountResponse,
RusotoError<DisassociateFromMasterAccountError>,
> {
let request_uri = format!(
"/detector/{detector_id}/master/disassociate",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DisassociateFromMasterAccountResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DisassociateFromMasterAccountError::from_response(response))
}
}
#[allow(unused_mut)]
async fn disassociate_members(
&self,
input: DisassociateMembersRequest,
) -> Result<DisassociateMembersResponse, RusotoError<DisassociateMembersError>> {
let request_uri = format!(
"/detector/{detector_id}/member/disassociate",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DisassociateMembersResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DisassociateMembersError::from_response(response))
}
}
#[allow(unused_mut)]
async fn enable_organization_admin_account(
&self,
input: EnableOrganizationAdminAccountRequest,
) -> Result<
EnableOrganizationAdminAccountResponse,
RusotoError<EnableOrganizationAdminAccountError>,
> {
let request_uri = "/admin/enable";
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<EnableOrganizationAdminAccountResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(EnableOrganizationAdminAccountError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_detector(
&self,
input: GetDetectorRequest,
) -> Result<GetDetectorResponse, RusotoError<GetDetectorError>> {
let request_uri = format!("/detector/{detector_id}", detector_id = input.detector_id);
let mut request = SignedRequest::new("GET", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetDetectorResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetDetectorError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_filter(
&self,
input: GetFilterRequest,
) -> Result<GetFilterResponse, RusotoError<GetFilterError>> {
let request_uri = format!(
"/detector/{detector_id}/filter/{filter_name}",
detector_id = input.detector_id,
filter_name = input.filter_name
);
let mut request = SignedRequest::new("GET", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetFilterResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetFilterError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_findings(
&self,
input: GetFindingsRequest,
) -> Result<GetFindingsResponse, RusotoError<GetFindingsError>> {
let request_uri = format!(
"/detector/{detector_id}/findings/get",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetFindingsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetFindingsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_findings_statistics(
&self,
input: GetFindingsStatisticsRequest,
) -> Result<GetFindingsStatisticsResponse, RusotoError<GetFindingsStatisticsError>> {
let request_uri = format!(
"/detector/{detector_id}/findings/statistics",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetFindingsStatisticsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetFindingsStatisticsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_ip_set(
&self,
input: GetIPSetRequest,
) -> Result<GetIPSetResponse, RusotoError<GetIPSetError>> {
let request_uri = format!(
"/detector/{detector_id}/ipset/{ip_set_id}",
detector_id = input.detector_id,
ip_set_id = input.ip_set_id
);
let mut request = SignedRequest::new("GET", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetIPSetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetIPSetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_invitations_count(
&self,
) -> Result<GetInvitationsCountResponse, RusotoError<GetInvitationsCountError>> {
let request_uri = "/invitation/count";
let mut request = SignedRequest::new("GET", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetInvitationsCountResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetInvitationsCountError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_master_account(
&self,
input: GetMasterAccountRequest,
) -> Result<GetMasterAccountResponse, RusotoError<GetMasterAccountError>> {
let request_uri = format!(
"/detector/{detector_id}/master",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("GET", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetMasterAccountResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetMasterAccountError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_member_detectors(
&self,
input: GetMemberDetectorsRequest,
) -> Result<GetMemberDetectorsResponse, RusotoError<GetMemberDetectorsError>> {
let request_uri = format!(
"/detector/{detector_id}/member/detector/get",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetMemberDetectorsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetMemberDetectorsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_members(
&self,
input: GetMembersRequest,
) -> Result<GetMembersResponse, RusotoError<GetMembersError>> {
let request_uri = format!(
"/detector/{detector_id}/member/get",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetMembersResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetMembersError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_threat_intel_set(
&self,
input: GetThreatIntelSetRequest,
) -> Result<GetThreatIntelSetResponse, RusotoError<GetThreatIntelSetError>> {
let request_uri = format!(
"/detector/{detector_id}/threatintelset/{threat_intel_set_id}",
detector_id = input.detector_id,
threat_intel_set_id = input.threat_intel_set_id
);
let mut request = SignedRequest::new("GET", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetThreatIntelSetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetThreatIntelSetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_usage_statistics(
&self,
input: GetUsageStatisticsRequest,
) -> Result<GetUsageStatisticsResponse, RusotoError<GetUsageStatisticsError>> {
let request_uri = format!(
"/detector/{detector_id}/usage/statistics",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetUsageStatisticsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetUsageStatisticsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn invite_members(
&self,
input: InviteMembersRequest,
) -> Result<InviteMembersResponse, RusotoError<InviteMembersError>> {
let request_uri = format!(
"/detector/{detector_id}/member/invite",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<InviteMembersResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(InviteMembersError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_detectors(
&self,
input: ListDetectorsRequest,
) -> Result<ListDetectorsResponse, RusotoError<ListDetectorsError>> {
let request_uri = "/detector";
let mut request = SignedRequest::new("GET", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListDetectorsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListDetectorsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_filters(
&self,
input: ListFiltersRequest,
) -> Result<ListFiltersResponse, RusotoError<ListFiltersError>> {
let request_uri = format!(
"/detector/{detector_id}/filter",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("GET", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListFiltersResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListFiltersError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_findings(
&self,
input: ListFindingsRequest,
) -> Result<ListFindingsResponse, RusotoError<ListFindingsError>> {
let request_uri = format!(
"/detector/{detector_id}/findings",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListFindingsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListFindingsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_ip_sets(
&self,
input: ListIPSetsRequest,
) -> Result<ListIPSetsResponse, RusotoError<ListIPSetsError>> {
let request_uri = format!(
"/detector/{detector_id}/ipset",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("GET", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListIPSetsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListIPSetsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_invitations(
&self,
input: ListInvitationsRequest,
) -> Result<ListInvitationsResponse, RusotoError<ListInvitationsError>> {
let request_uri = "/invitation";
let mut request = SignedRequest::new("GET", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListInvitationsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListInvitationsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_members(
&self,
input: ListMembersRequest,
) -> Result<ListMembersResponse, RusotoError<ListMembersError>> {
let request_uri = format!(
"/detector/{detector_id}/member",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("GET", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
if let Some(ref x) = input.only_associated {
params.put("onlyAssociated", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListMembersResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListMembersError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_organization_admin_accounts(
&self,
input: ListOrganizationAdminAccountsRequest,
) -> Result<
ListOrganizationAdminAccountsResponse,
RusotoError<ListOrganizationAdminAccountsError>,
> {
let request_uri = "/admin";
let mut request = SignedRequest::new("GET", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListOrganizationAdminAccountsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListOrganizationAdminAccountsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_publishing_destinations(
&self,
input: ListPublishingDestinationsRequest,
) -> Result<ListPublishingDestinationsResponse, RusotoError<ListPublishingDestinationsError>>
{
let request_uri = format!(
"/detector/{detector_id}/publishingDestination",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("GET", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListPublishingDestinationsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListPublishingDestinationsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("GET", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListTagsForResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListTagsForResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_threat_intel_sets(
&self,
input: ListThreatIntelSetsRequest,
) -> Result<ListThreatIntelSetsResponse, RusotoError<ListThreatIntelSetsError>> {
let request_uri = format!(
"/detector/{detector_id}/threatintelset",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("GET", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListThreatIntelSetsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListThreatIntelSetsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn start_monitoring_members(
&self,
input: StartMonitoringMembersRequest,
) -> Result<StartMonitoringMembersResponse, RusotoError<StartMonitoringMembersError>> {
let request_uri = format!(
"/detector/{detector_id}/member/start",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<StartMonitoringMembersResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(StartMonitoringMembersError::from_response(response))
}
}
#[allow(unused_mut)]
async fn stop_monitoring_members(
&self,
input: StopMonitoringMembersRequest,
) -> Result<StopMonitoringMembersResponse, RusotoError<StopMonitoringMembersError>> {
let request_uri = format!(
"/detector/{detector_id}/member/stop",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<StopMonitoringMembersResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(StopMonitoringMembersError::from_response(response))
}
}
#[allow(unused_mut)]
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<TagResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(TagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn unarchive_findings(
&self,
input: UnarchiveFindingsRequest,
) -> Result<UnarchiveFindingsResponse, RusotoError<UnarchiveFindingsError>> {
let request_uri = format!(
"/detector/{detector_id}/findings/unarchive",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UnarchiveFindingsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UnarchiveFindingsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("DELETE", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
for item in input.tag_keys.iter() {
params.put("tagKeys", item);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UntagResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UntagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_detector(
&self,
input: UpdateDetectorRequest,
) -> Result<UpdateDetectorResponse, RusotoError<UpdateDetectorError>> {
let request_uri = format!("/detector/{detector_id}", detector_id = input.detector_id);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateDetectorResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateDetectorError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_filter(
&self,
input: UpdateFilterRequest,
) -> Result<UpdateFilterResponse, RusotoError<UpdateFilterError>> {
let request_uri = format!(
"/detector/{detector_id}/filter/{filter_name}",
detector_id = input.detector_id,
filter_name = input.filter_name
);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateFilterResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateFilterError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_findings_feedback(
&self,
input: UpdateFindingsFeedbackRequest,
) -> Result<UpdateFindingsFeedbackResponse, RusotoError<UpdateFindingsFeedbackError>> {
let request_uri = format!(
"/detector/{detector_id}/findings/feedback",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateFindingsFeedbackResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateFindingsFeedbackError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_ip_set(
&self,
input: UpdateIPSetRequest,
) -> Result<UpdateIPSetResponse, RusotoError<UpdateIPSetError>> {
let request_uri = format!(
"/detector/{detector_id}/ipset/{ip_set_id}",
detector_id = input.detector_id,
ip_set_id = input.ip_set_id
);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateIPSetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateIPSetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_member_detectors(
&self,
input: UpdateMemberDetectorsRequest,
) -> Result<UpdateMemberDetectorsResponse, RusotoError<UpdateMemberDetectorsError>> {
let request_uri = format!(
"/detector/{detector_id}/member/detector/update",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateMemberDetectorsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateMemberDetectorsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_organization_configuration(
&self,
input: UpdateOrganizationConfigurationRequest,
) -> Result<
UpdateOrganizationConfigurationResponse,
RusotoError<UpdateOrganizationConfigurationError>,
> {
let request_uri = format!(
"/detector/{detector_id}/admin",
detector_id = input.detector_id
);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateOrganizationConfigurationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateOrganizationConfigurationError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn update_publishing_destination(
&self,
input: UpdatePublishingDestinationRequest,
) -> Result<UpdatePublishingDestinationResponse, RusotoError<UpdatePublishingDestinationError>>
{
let request_uri = format!(
"/detector/{detector_id}/publishingDestination/{destination_id}",
destination_id = input.destination_id,
detector_id = input.detector_id
);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdatePublishingDestinationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdatePublishingDestinationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_threat_intel_set(
&self,
input: UpdateThreatIntelSetRequest,
) -> Result<UpdateThreatIntelSetResponse, RusotoError<UpdateThreatIntelSetError>> {
let request_uri = format!(
"/detector/{detector_id}/threatintelset/{threat_intel_set_id}",
detector_id = input.detector_id,
threat_intel_set_id = input.threat_intel_set_id
);
let mut request = SignedRequest::new("POST", "guardduty", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateThreatIntelSetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateThreatIntelSetError::from_response(response))
}
}
}