#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UpdateNotificationRuleOutput {}
pub mod update_notification_rule_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(self) -> crate::output::UpdateNotificationRuleOutput {
crate::output::UpdateNotificationRuleOutput {}
}
}
}
impl UpdateNotificationRuleOutput {
pub fn builder() -> crate::output::update_notification_rule_output::Builder {
crate::output::update_notification_rule_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UntagResourceOutput {}
pub mod untag_resource_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(self) -> crate::output::UntagResourceOutput {
crate::output::UntagResourceOutput {}
}
}
}
impl UntagResourceOutput {
pub fn builder() -> crate::output::untag_resource_output::Builder {
crate::output::untag_resource_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UnsubscribeOutput {
#[doc(hidden)]
pub arn: std::option::Option<std::string::String>,
}
impl UnsubscribeOutput {
pub fn arn(&self) -> std::option::Option<&str> {
self.arn.as_deref()
}
}
pub mod unsubscribe_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
self.arn = Some(input.into());
self
}
pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.arn = input;
self
}
pub fn build(self) -> crate::output::UnsubscribeOutput {
crate::output::UnsubscribeOutput { arn: self.arn }
}
}
}
impl UnsubscribeOutput {
pub fn builder() -> crate::output::unsubscribe_output::Builder {
crate::output::unsubscribe_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct TagResourceOutput {
#[doc(hidden)]
pub tags:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl TagResourceOutput {
pub fn tags(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.tags.as_ref()
}
}
pub mod tag_resource_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) tags: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
}
impl Builder {
pub fn tags(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.tags.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.tags = Some(hash_map);
self
}
pub fn set_tags(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.tags = input;
self
}
pub fn build(self) -> crate::output::TagResourceOutput {
crate::output::TagResourceOutput { tags: self.tags }
}
}
}
impl TagResourceOutput {
pub fn builder() -> crate::output::tag_resource_output::Builder {
crate::output::tag_resource_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct SubscribeOutput {
#[doc(hidden)]
pub arn: std::option::Option<std::string::String>,
}
impl SubscribeOutput {
pub fn arn(&self) -> std::option::Option<&str> {
self.arn.as_deref()
}
}
pub mod subscribe_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
self.arn = Some(input.into());
self
}
pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.arn = input;
self
}
pub fn build(self) -> crate::output::SubscribeOutput {
crate::output::SubscribeOutput { arn: self.arn }
}
}
}
impl SubscribeOutput {
pub fn builder() -> crate::output::subscribe_output::Builder {
crate::output::subscribe_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListTargetsOutput {
#[doc(hidden)]
pub targets: std::option::Option<std::vec::Vec<crate::model::TargetSummary>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl ListTargetsOutput {
pub fn targets(&self) -> std::option::Option<&[crate::model::TargetSummary]> {
self.targets.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod list_targets_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) targets: std::option::Option<std::vec::Vec<crate::model::TargetSummary>>,
pub(crate) next_token: std::option::Option<std::string::String>,
}
impl Builder {
pub fn targets(mut self, input: crate::model::TargetSummary) -> Self {
let mut v = self.targets.unwrap_or_default();
v.push(input);
self.targets = Some(v);
self
}
pub fn set_targets(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::TargetSummary>>,
) -> Self {
self.targets = input;
self
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn build(self) -> crate::output::ListTargetsOutput {
crate::output::ListTargetsOutput {
targets: self.targets,
next_token: self.next_token,
}
}
}
}
impl ListTargetsOutput {
pub fn builder() -> crate::output::list_targets_output::Builder {
crate::output::list_targets_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListTagsForResourceOutput {
#[doc(hidden)]
pub tags:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl ListTagsForResourceOutput {
pub fn tags(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.tags.as_ref()
}
}
pub mod list_tags_for_resource_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) tags: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
}
impl Builder {
pub fn tags(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.tags.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.tags = Some(hash_map);
self
}
pub fn set_tags(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.tags = input;
self
}
pub fn build(self) -> crate::output::ListTagsForResourceOutput {
crate::output::ListTagsForResourceOutput { tags: self.tags }
}
}
}
impl ListTagsForResourceOutput {
pub fn builder() -> crate::output::list_tags_for_resource_output::Builder {
crate::output::list_tags_for_resource_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListNotificationRulesOutput {
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
#[doc(hidden)]
pub notification_rules:
std::option::Option<std::vec::Vec<crate::model::NotificationRuleSummary>>,
}
impl ListNotificationRulesOutput {
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
pub fn notification_rules(
&self,
) -> std::option::Option<&[crate::model::NotificationRuleSummary]> {
self.notification_rules.as_deref()
}
}
pub mod list_notification_rules_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) notification_rules:
std::option::Option<std::vec::Vec<crate::model::NotificationRuleSummary>>,
}
impl Builder {
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn notification_rules(mut self, input: crate::model::NotificationRuleSummary) -> Self {
let mut v = self.notification_rules.unwrap_or_default();
v.push(input);
self.notification_rules = Some(v);
self
}
pub fn set_notification_rules(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::NotificationRuleSummary>>,
) -> Self {
self.notification_rules = input;
self
}
pub fn build(self) -> crate::output::ListNotificationRulesOutput {
crate::output::ListNotificationRulesOutput {
next_token: self.next_token,
notification_rules: self.notification_rules,
}
}
}
}
impl ListNotificationRulesOutput {
pub fn builder() -> crate::output::list_notification_rules_output::Builder {
crate::output::list_notification_rules_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListEventTypesOutput {
#[doc(hidden)]
pub event_types: std::option::Option<std::vec::Vec<crate::model::EventTypeSummary>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl ListEventTypesOutput {
pub fn event_types(&self) -> std::option::Option<&[crate::model::EventTypeSummary]> {
self.event_types.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod list_event_types_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) event_types: std::option::Option<std::vec::Vec<crate::model::EventTypeSummary>>,
pub(crate) next_token: std::option::Option<std::string::String>,
}
impl Builder {
pub fn event_types(mut self, input: crate::model::EventTypeSummary) -> Self {
let mut v = self.event_types.unwrap_or_default();
v.push(input);
self.event_types = Some(v);
self
}
pub fn set_event_types(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::EventTypeSummary>>,
) -> Self {
self.event_types = input;
self
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn build(self) -> crate::output::ListEventTypesOutput {
crate::output::ListEventTypesOutput {
event_types: self.event_types,
next_token: self.next_token,
}
}
}
}
impl ListEventTypesOutput {
pub fn builder() -> crate::output::list_event_types_output::Builder {
crate::output::list_event_types_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeNotificationRuleOutput {
#[doc(hidden)]
pub arn: std::option::Option<std::string::String>,
#[doc(hidden)]
pub name: std::option::Option<std::string::String>,
#[doc(hidden)]
pub event_types: std::option::Option<std::vec::Vec<crate::model::EventTypeSummary>>,
#[doc(hidden)]
pub resource: std::option::Option<std::string::String>,
#[doc(hidden)]
pub targets: std::option::Option<std::vec::Vec<crate::model::TargetSummary>>,
#[doc(hidden)]
pub detail_type: std::option::Option<crate::model::DetailType>,
#[doc(hidden)]
pub created_by: std::option::Option<std::string::String>,
#[doc(hidden)]
pub status: std::option::Option<crate::model::NotificationRuleStatus>,
#[doc(hidden)]
pub created_timestamp: std::option::Option<aws_smithy_types::DateTime>,
#[doc(hidden)]
pub last_modified_timestamp: std::option::Option<aws_smithy_types::DateTime>,
#[doc(hidden)]
pub tags:
std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl DescribeNotificationRuleOutput {
pub fn arn(&self) -> std::option::Option<&str> {
self.arn.as_deref()
}
pub fn name(&self) -> std::option::Option<&str> {
self.name.as_deref()
}
pub fn event_types(&self) -> std::option::Option<&[crate::model::EventTypeSummary]> {
self.event_types.as_deref()
}
pub fn resource(&self) -> std::option::Option<&str> {
self.resource.as_deref()
}
pub fn targets(&self) -> std::option::Option<&[crate::model::TargetSummary]> {
self.targets.as_deref()
}
pub fn detail_type(&self) -> std::option::Option<&crate::model::DetailType> {
self.detail_type.as_ref()
}
pub fn created_by(&self) -> std::option::Option<&str> {
self.created_by.as_deref()
}
pub fn status(&self) -> std::option::Option<&crate::model::NotificationRuleStatus> {
self.status.as_ref()
}
pub fn created_timestamp(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.created_timestamp.as_ref()
}
pub fn last_modified_timestamp(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.last_modified_timestamp.as_ref()
}
pub fn tags(
&self,
) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
{
self.tags.as_ref()
}
}
impl std::fmt::Debug for DescribeNotificationRuleOutput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("DescribeNotificationRuleOutput");
formatter.field("arn", &self.arn);
formatter.field("name", &"*** Sensitive Data Redacted ***");
formatter.field("event_types", &self.event_types);
formatter.field("resource", &self.resource);
formatter.field("targets", &self.targets);
formatter.field("detail_type", &self.detail_type);
formatter.field("created_by", &self.created_by);
formatter.field("status", &self.status);
formatter.field("created_timestamp", &self.created_timestamp);
formatter.field("last_modified_timestamp", &self.last_modified_timestamp);
formatter.field("tags", &self.tags);
formatter.finish()
}
}
pub mod describe_notification_rule_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default)]
pub struct Builder {
pub(crate) arn: std::option::Option<std::string::String>,
pub(crate) name: std::option::Option<std::string::String>,
pub(crate) event_types: std::option::Option<std::vec::Vec<crate::model::EventTypeSummary>>,
pub(crate) resource: std::option::Option<std::string::String>,
pub(crate) targets: std::option::Option<std::vec::Vec<crate::model::TargetSummary>>,
pub(crate) detail_type: std::option::Option<crate::model::DetailType>,
pub(crate) created_by: std::option::Option<std::string::String>,
pub(crate) status: std::option::Option<crate::model::NotificationRuleStatus>,
pub(crate) created_timestamp: std::option::Option<aws_smithy_types::DateTime>,
pub(crate) last_modified_timestamp: std::option::Option<aws_smithy_types::DateTime>,
pub(crate) tags: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
}
impl Builder {
pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
self.arn = Some(input.into());
self
}
pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.arn = input;
self
}
pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
self.name = Some(input.into());
self
}
pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
self.name = input;
self
}
pub fn event_types(mut self, input: crate::model::EventTypeSummary) -> Self {
let mut v = self.event_types.unwrap_or_default();
v.push(input);
self.event_types = Some(v);
self
}
pub fn set_event_types(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::EventTypeSummary>>,
) -> Self {
self.event_types = input;
self
}
pub fn resource(mut self, input: impl Into<std::string::String>) -> Self {
self.resource = Some(input.into());
self
}
pub fn set_resource(mut self, input: std::option::Option<std::string::String>) -> Self {
self.resource = input;
self
}
pub fn targets(mut self, input: crate::model::TargetSummary) -> Self {
let mut v = self.targets.unwrap_or_default();
v.push(input);
self.targets = Some(v);
self
}
pub fn set_targets(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::TargetSummary>>,
) -> Self {
self.targets = input;
self
}
pub fn detail_type(mut self, input: crate::model::DetailType) -> Self {
self.detail_type = Some(input);
self
}
pub fn set_detail_type(
mut self,
input: std::option::Option<crate::model::DetailType>,
) -> Self {
self.detail_type = input;
self
}
pub fn created_by(mut self, input: impl Into<std::string::String>) -> Self {
self.created_by = Some(input.into());
self
}
pub fn set_created_by(mut self, input: std::option::Option<std::string::String>) -> Self {
self.created_by = input;
self
}
pub fn status(mut self, input: crate::model::NotificationRuleStatus) -> Self {
self.status = Some(input);
self
}
pub fn set_status(
mut self,
input: std::option::Option<crate::model::NotificationRuleStatus>,
) -> Self {
self.status = input;
self
}
pub fn created_timestamp(mut self, input: aws_smithy_types::DateTime) -> Self {
self.created_timestamp = Some(input);
self
}
pub fn set_created_timestamp(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.created_timestamp = input;
self
}
pub fn last_modified_timestamp(mut self, input: aws_smithy_types::DateTime) -> Self {
self.last_modified_timestamp = Some(input);
self
}
pub fn set_last_modified_timestamp(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.last_modified_timestamp = input;
self
}
pub fn tags(
mut self,
k: impl Into<std::string::String>,
v: impl Into<std::string::String>,
) -> Self {
let mut hash_map = self.tags.unwrap_or_default();
hash_map.insert(k.into(), v.into());
self.tags = Some(hash_map);
self
}
pub fn set_tags(
mut self,
input: std::option::Option<
std::collections::HashMap<std::string::String, std::string::String>,
>,
) -> Self {
self.tags = input;
self
}
pub fn build(self) -> crate::output::DescribeNotificationRuleOutput {
crate::output::DescribeNotificationRuleOutput {
arn: self.arn,
name: self.name,
event_types: self.event_types,
resource: self.resource,
targets: self.targets,
detail_type: self.detail_type,
created_by: self.created_by,
status: self.status,
created_timestamp: self.created_timestamp,
last_modified_timestamp: self.last_modified_timestamp,
tags: self.tags,
}
}
}
impl std::fmt::Debug for Builder {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut formatter = f.debug_struct("Builder");
formatter.field("arn", &self.arn);
formatter.field("name", &"*** Sensitive Data Redacted ***");
formatter.field("event_types", &self.event_types);
formatter.field("resource", &self.resource);
formatter.field("targets", &self.targets);
formatter.field("detail_type", &self.detail_type);
formatter.field("created_by", &self.created_by);
formatter.field("status", &self.status);
formatter.field("created_timestamp", &self.created_timestamp);
formatter.field("last_modified_timestamp", &self.last_modified_timestamp);
formatter.field("tags", &self.tags);
formatter.finish()
}
}
}
impl DescribeNotificationRuleOutput {
pub fn builder() -> crate::output::describe_notification_rule_output::Builder {
crate::output::describe_notification_rule_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteTargetOutput {}
pub mod delete_target_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(self) -> crate::output::DeleteTargetOutput {
crate::output::DeleteTargetOutput {}
}
}
}
impl DeleteTargetOutput {
pub fn builder() -> crate::output::delete_target_output::Builder {
crate::output::delete_target_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteNotificationRuleOutput {
#[doc(hidden)]
pub arn: std::option::Option<std::string::String>,
}
impl DeleteNotificationRuleOutput {
pub fn arn(&self) -> std::option::Option<&str> {
self.arn.as_deref()
}
}
pub mod delete_notification_rule_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
self.arn = Some(input.into());
self
}
pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.arn = input;
self
}
pub fn build(self) -> crate::output::DeleteNotificationRuleOutput {
crate::output::DeleteNotificationRuleOutput { arn: self.arn }
}
}
}
impl DeleteNotificationRuleOutput {
pub fn builder() -> crate::output::delete_notification_rule_output::Builder {
crate::output::delete_notification_rule_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreateNotificationRuleOutput {
#[doc(hidden)]
pub arn: std::option::Option<std::string::String>,
}
impl CreateNotificationRuleOutput {
pub fn arn(&self) -> std::option::Option<&str> {
self.arn.as_deref()
}
}
pub mod create_notification_rule_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn arn(mut self, input: impl Into<std::string::String>) -> Self {
self.arn = Some(input.into());
self
}
pub fn set_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.arn = input;
self
}
pub fn build(self) -> crate::output::CreateNotificationRuleOutput {
crate::output::CreateNotificationRuleOutput { arn: self.arn }
}
}
}
impl CreateNotificationRuleOutput {
pub fn builder() -> crate::output::create_notification_rule_output::Builder {
crate::output::create_notification_rule_output::Builder::default()
}
}