# coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs

__all__ = [
    'ConfigurationSetEventDestinationCloudWatchDestination',
    'ConfigurationSetEventDestinationDimensionConfiguration',
    'ConfigurationSetEventDestinationEventDestination',
    'ConfigurationSetEventDestinationKinesisFirehoseDestination',
    'ContactListTag',
    'ContactListTopic',
    'ReceiptFilterFilter',
    'ReceiptFilterIpFilter',
    'ReceiptRuleAction',
    'ReceiptRuleAddHeaderAction',
    'ReceiptRuleBounceAction',
    'ReceiptRuleLambdaAction',
    'ReceiptRuleRule',
    'ReceiptRuleS3Action',
    'ReceiptRuleSNSAction',
    'ReceiptRuleStopAction',
    'ReceiptRuleWorkmailAction',
    'TemplateTemplate',
]

@pulumi.output_type
class ConfigurationSetEventDestinationCloudWatchDestination(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dimensionConfigurations":
            suggest = "dimension_configurations"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ConfigurationSetEventDestinationCloudWatchDestination. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ConfigurationSetEventDestinationCloudWatchDestination.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ConfigurationSetEventDestinationCloudWatchDestination.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 dimension_configurations: Optional[Sequence['outputs.ConfigurationSetEventDestinationDimensionConfiguration']] = None):
        if dimension_configurations is not None:
            pulumi.set(__self__, "dimension_configurations", dimension_configurations)

    @property
    @pulumi.getter(name="dimensionConfigurations")
    def dimension_configurations(self) -> Optional[Sequence['outputs.ConfigurationSetEventDestinationDimensionConfiguration']]:
        return pulumi.get(self, "dimension_configurations")


@pulumi.output_type
class ConfigurationSetEventDestinationDimensionConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultDimensionValue":
            suggest = "default_dimension_value"
        elif key == "dimensionName":
            suggest = "dimension_name"
        elif key == "dimensionValueSource":
            suggest = "dimension_value_source"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ConfigurationSetEventDestinationDimensionConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ConfigurationSetEventDestinationDimensionConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ConfigurationSetEventDestinationDimensionConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 default_dimension_value: str,
                 dimension_name: str,
                 dimension_value_source: str):
        pulumi.set(__self__, "default_dimension_value", default_dimension_value)
        pulumi.set(__self__, "dimension_name", dimension_name)
        pulumi.set(__self__, "dimension_value_source", dimension_value_source)

    @property
    @pulumi.getter(name="defaultDimensionValue")
    def default_dimension_value(self) -> str:
        return pulumi.get(self, "default_dimension_value")

    @property
    @pulumi.getter(name="dimensionName")
    def dimension_name(self) -> str:
        return pulumi.get(self, "dimension_name")

    @property
    @pulumi.getter(name="dimensionValueSource")
    def dimension_value_source(self) -> str:
        return pulumi.get(self, "dimension_value_source")


@pulumi.output_type
class ConfigurationSetEventDestinationEventDestination(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "matchingEventTypes":
            suggest = "matching_event_types"
        elif key == "cloudWatchDestination":
            suggest = "cloud_watch_destination"
        elif key == "kinesisFirehoseDestination":
            suggest = "kinesis_firehose_destination"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ConfigurationSetEventDestinationEventDestination. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ConfigurationSetEventDestinationEventDestination.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ConfigurationSetEventDestinationEventDestination.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 matching_event_types: Sequence[str],
                 cloud_watch_destination: Optional['outputs.ConfigurationSetEventDestinationCloudWatchDestination'] = None,
                 enabled: Optional[bool] = None,
                 kinesis_firehose_destination: Optional['outputs.ConfigurationSetEventDestinationKinesisFirehoseDestination'] = None,
                 name: Optional[str] = None):
        pulumi.set(__self__, "matching_event_types", matching_event_types)
        if cloud_watch_destination is not None:
            pulumi.set(__self__, "cloud_watch_destination", cloud_watch_destination)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if kinesis_firehose_destination is not None:
            pulumi.set(__self__, "kinesis_firehose_destination", kinesis_firehose_destination)
        if name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter(name="matchingEventTypes")
    def matching_event_types(self) -> Sequence[str]:
        return pulumi.get(self, "matching_event_types")

    @property
    @pulumi.getter(name="cloudWatchDestination")
    def cloud_watch_destination(self) -> Optional['outputs.ConfigurationSetEventDestinationCloudWatchDestination']:
        return pulumi.get(self, "cloud_watch_destination")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="kinesisFirehoseDestination")
    def kinesis_firehose_destination(self) -> Optional['outputs.ConfigurationSetEventDestinationKinesisFirehoseDestination']:
        return pulumi.get(self, "kinesis_firehose_destination")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        return pulumi.get(self, "name")


@pulumi.output_type
class ConfigurationSetEventDestinationKinesisFirehoseDestination(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deliveryStreamARN":
            suggest = "delivery_stream_arn"
        elif key == "iAMRoleARN":
            suggest = "i_am_role_arn"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ConfigurationSetEventDestinationKinesisFirehoseDestination. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ConfigurationSetEventDestinationKinesisFirehoseDestination.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ConfigurationSetEventDestinationKinesisFirehoseDestination.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 delivery_stream_arn: str,
                 i_am_role_arn: str):
        pulumi.set(__self__, "delivery_stream_arn", delivery_stream_arn)
        pulumi.set(__self__, "i_am_role_arn", i_am_role_arn)

    @property
    @pulumi.getter(name="deliveryStreamARN")
    def delivery_stream_arn(self) -> str:
        return pulumi.get(self, "delivery_stream_arn")

    @property
    @pulumi.getter(name="iAMRoleARN")
    def i_am_role_arn(self) -> str:
        return pulumi.get(self, "i_am_role_arn")


@pulumi.output_type
class ContactListTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class ContactListTopic(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultSubscriptionStatus":
            suggest = "default_subscription_status"
        elif key == "displayName":
            suggest = "display_name"
        elif key == "topicName":
            suggest = "topic_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ContactListTopic. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ContactListTopic.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ContactListTopic.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 default_subscription_status: str,
                 display_name: str,
                 topic_name: str,
                 description: Optional[str] = None):
        """
        :param str display_name: The display name of the topic.
        :param str topic_name: The name of the topic.
        :param str description: The description of the topic.
        """
        pulumi.set(__self__, "default_subscription_status", default_subscription_status)
        pulumi.set(__self__, "display_name", display_name)
        pulumi.set(__self__, "topic_name", topic_name)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter(name="defaultSubscriptionStatus")
    def default_subscription_status(self) -> str:
        return pulumi.get(self, "default_subscription_status")

    @property
    @pulumi.getter(name="displayName")
    def display_name(self) -> str:
        """
        The display name of the topic.
        """
        return pulumi.get(self, "display_name")

    @property
    @pulumi.getter(name="topicName")
    def topic_name(self) -> str:
        """
        The name of the topic.
        """
        return pulumi.get(self, "topic_name")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        The description of the topic.
        """
        return pulumi.get(self, "description")


@pulumi.output_type
class ReceiptFilterFilter(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ipFilter":
            suggest = "ip_filter"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ReceiptFilterFilter. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ReceiptFilterFilter.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ReceiptFilterFilter.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ip_filter: 'outputs.ReceiptFilterIpFilter',
                 name: Optional[str] = None):
        pulumi.set(__self__, "ip_filter", ip_filter)
        if name is not None:
            pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter(name="ipFilter")
    def ip_filter(self) -> 'outputs.ReceiptFilterIpFilter':
        return pulumi.get(self, "ip_filter")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        return pulumi.get(self, "name")


@pulumi.output_type
class ReceiptFilterIpFilter(dict):
    def __init__(__self__, *,
                 cidr: str,
                 policy: str):
        pulumi.set(__self__, "cidr", cidr)
        pulumi.set(__self__, "policy", policy)

    @property
    @pulumi.getter
    def cidr(self) -> str:
        return pulumi.get(self, "cidr")

    @property
    @pulumi.getter
    def policy(self) -> str:
        return pulumi.get(self, "policy")


@pulumi.output_type
class ReceiptRuleAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "addHeaderAction":
            suggest = "add_header_action"
        elif key == "bounceAction":
            suggest = "bounce_action"
        elif key == "lambdaAction":
            suggest = "lambda_action"
        elif key == "s3Action":
            suggest = "s3_action"
        elif key == "sNSAction":
            suggest = "s_ns_action"
        elif key == "stopAction":
            suggest = "stop_action"
        elif key == "workmailAction":
            suggest = "workmail_action"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ReceiptRuleAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ReceiptRuleAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ReceiptRuleAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 add_header_action: Optional['outputs.ReceiptRuleAddHeaderAction'] = None,
                 bounce_action: Optional['outputs.ReceiptRuleBounceAction'] = None,
                 lambda_action: Optional['outputs.ReceiptRuleLambdaAction'] = None,
                 s3_action: Optional['outputs.ReceiptRuleS3Action'] = None,
                 s_ns_action: Optional['outputs.ReceiptRuleSNSAction'] = None,
                 stop_action: Optional['outputs.ReceiptRuleStopAction'] = None,
                 workmail_action: Optional['outputs.ReceiptRuleWorkmailAction'] = None):
        if add_header_action is not None:
            pulumi.set(__self__, "add_header_action", add_header_action)
        if bounce_action is not None:
            pulumi.set(__self__, "bounce_action", bounce_action)
        if lambda_action is not None:
            pulumi.set(__self__, "lambda_action", lambda_action)
        if s3_action is not None:
            pulumi.set(__self__, "s3_action", s3_action)
        if s_ns_action is not None:
            pulumi.set(__self__, "s_ns_action", s_ns_action)
        if stop_action is not None:
            pulumi.set(__self__, "stop_action", stop_action)
        if workmail_action is not None:
            pulumi.set(__self__, "workmail_action", workmail_action)

    @property
    @pulumi.getter(name="addHeaderAction")
    def add_header_action(self) -> Optional['outputs.ReceiptRuleAddHeaderAction']:
        return pulumi.get(self, "add_header_action")

    @property
    @pulumi.getter(name="bounceAction")
    def bounce_action(self) -> Optional['outputs.ReceiptRuleBounceAction']:
        return pulumi.get(self, "bounce_action")

    @property
    @pulumi.getter(name="lambdaAction")
    def lambda_action(self) -> Optional['outputs.ReceiptRuleLambdaAction']:
        return pulumi.get(self, "lambda_action")

    @property
    @pulumi.getter(name="s3Action")
    def s3_action(self) -> Optional['outputs.ReceiptRuleS3Action']:
        return pulumi.get(self, "s3_action")

    @property
    @pulumi.getter(name="sNSAction")
    def s_ns_action(self) -> Optional['outputs.ReceiptRuleSNSAction']:
        return pulumi.get(self, "s_ns_action")

    @property
    @pulumi.getter(name="stopAction")
    def stop_action(self) -> Optional['outputs.ReceiptRuleStopAction']:
        return pulumi.get(self, "stop_action")

    @property
    @pulumi.getter(name="workmailAction")
    def workmail_action(self) -> Optional['outputs.ReceiptRuleWorkmailAction']:
        return pulumi.get(self, "workmail_action")


@pulumi.output_type
class ReceiptRuleAddHeaderAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "headerName":
            suggest = "header_name"
        elif key == "headerValue":
            suggest = "header_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ReceiptRuleAddHeaderAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ReceiptRuleAddHeaderAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ReceiptRuleAddHeaderAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 header_name: str,
                 header_value: str):
        pulumi.set(__self__, "header_name", header_name)
        pulumi.set(__self__, "header_value", header_value)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> str:
        return pulumi.get(self, "header_name")

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> str:
        return pulumi.get(self, "header_value")


@pulumi.output_type
class ReceiptRuleBounceAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "smtpReplyCode":
            suggest = "smtp_reply_code"
        elif key == "statusCode":
            suggest = "status_code"
        elif key == "topicArn":
            suggest = "topic_arn"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ReceiptRuleBounceAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ReceiptRuleBounceAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ReceiptRuleBounceAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 message: str,
                 sender: str,
                 smtp_reply_code: str,
                 status_code: Optional[str] = None,
                 topic_arn: Optional[str] = None):
        pulumi.set(__self__, "message", message)
        pulumi.set(__self__, "sender", sender)
        pulumi.set(__self__, "smtp_reply_code", smtp_reply_code)
        if status_code is not None:
            pulumi.set(__self__, "status_code", status_code)
        if topic_arn is not None:
            pulumi.set(__self__, "topic_arn", topic_arn)

    @property
    @pulumi.getter
    def message(self) -> str:
        return pulumi.get(self, "message")

    @property
    @pulumi.getter
    def sender(self) -> str:
        return pulumi.get(self, "sender")

    @property
    @pulumi.getter(name="smtpReplyCode")
    def smtp_reply_code(self) -> str:
        return pulumi.get(self, "smtp_reply_code")

    @property
    @pulumi.getter(name="statusCode")
    def status_code(self) -> Optional[str]:
        return pulumi.get(self, "status_code")

    @property
    @pulumi.getter(name="topicArn")
    def topic_arn(self) -> Optional[str]:
        return pulumi.get(self, "topic_arn")


@pulumi.output_type
class ReceiptRuleLambdaAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "functionArn":
            suggest = "function_arn"
        elif key == "invocationType":
            suggest = "invocation_type"
        elif key == "topicArn":
            suggest = "topic_arn"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ReceiptRuleLambdaAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ReceiptRuleLambdaAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ReceiptRuleLambdaAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 function_arn: str,
                 invocation_type: Optional[str] = None,
                 topic_arn: Optional[str] = None):
        pulumi.set(__self__, "function_arn", function_arn)
        if invocation_type is not None:
            pulumi.set(__self__, "invocation_type", invocation_type)
        if topic_arn is not None:
            pulumi.set(__self__, "topic_arn", topic_arn)

    @property
    @pulumi.getter(name="functionArn")
    def function_arn(self) -> str:
        return pulumi.get(self, "function_arn")

    @property
    @pulumi.getter(name="invocationType")
    def invocation_type(self) -> Optional[str]:
        return pulumi.get(self, "invocation_type")

    @property
    @pulumi.getter(name="topicArn")
    def topic_arn(self) -> Optional[str]:
        return pulumi.get(self, "topic_arn")


@pulumi.output_type
class ReceiptRuleRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "scanEnabled":
            suggest = "scan_enabled"
        elif key == "tlsPolicy":
            suggest = "tls_policy"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ReceiptRuleRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ReceiptRuleRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ReceiptRuleRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 actions: Optional[Sequence['outputs.ReceiptRuleAction']] = None,
                 enabled: Optional[bool] = None,
                 name: Optional[str] = None,
                 recipients: Optional[Sequence[str]] = None,
                 scan_enabled: Optional[bool] = None,
                 tls_policy: Optional[str] = None):
        if actions is not None:
            pulumi.set(__self__, "actions", actions)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if recipients is not None:
            pulumi.set(__self__, "recipients", recipients)
        if scan_enabled is not None:
            pulumi.set(__self__, "scan_enabled", scan_enabled)
        if tls_policy is not None:
            pulumi.set(__self__, "tls_policy", tls_policy)

    @property
    @pulumi.getter
    def actions(self) -> Optional[Sequence['outputs.ReceiptRuleAction']]:
        return pulumi.get(self, "actions")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def recipients(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "recipients")

    @property
    @pulumi.getter(name="scanEnabled")
    def scan_enabled(self) -> Optional[bool]:
        return pulumi.get(self, "scan_enabled")

    @property
    @pulumi.getter(name="tlsPolicy")
    def tls_policy(self) -> Optional[str]:
        return pulumi.get(self, "tls_policy")


@pulumi.output_type
class ReceiptRuleS3Action(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bucketName":
            suggest = "bucket_name"
        elif key == "kmsKeyArn":
            suggest = "kms_key_arn"
        elif key == "objectKeyPrefix":
            suggest = "object_key_prefix"
        elif key == "topicArn":
            suggest = "topic_arn"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ReceiptRuleS3Action. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ReceiptRuleS3Action.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ReceiptRuleS3Action.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 bucket_name: str,
                 kms_key_arn: Optional[str] = None,
                 object_key_prefix: Optional[str] = None,
                 topic_arn: Optional[str] = None):
        pulumi.set(__self__, "bucket_name", bucket_name)
        if kms_key_arn is not None:
            pulumi.set(__self__, "kms_key_arn", kms_key_arn)
        if object_key_prefix is not None:
            pulumi.set(__self__, "object_key_prefix", object_key_prefix)
        if topic_arn is not None:
            pulumi.set(__self__, "topic_arn", topic_arn)

    @property
    @pulumi.getter(name="bucketName")
    def bucket_name(self) -> str:
        return pulumi.get(self, "bucket_name")

    @property
    @pulumi.getter(name="kmsKeyArn")
    def kms_key_arn(self) -> Optional[str]:
        return pulumi.get(self, "kms_key_arn")

    @property
    @pulumi.getter(name="objectKeyPrefix")
    def object_key_prefix(self) -> Optional[str]:
        return pulumi.get(self, "object_key_prefix")

    @property
    @pulumi.getter(name="topicArn")
    def topic_arn(self) -> Optional[str]:
        return pulumi.get(self, "topic_arn")


@pulumi.output_type
class ReceiptRuleSNSAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "topicArn":
            suggest = "topic_arn"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ReceiptRuleSNSAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ReceiptRuleSNSAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ReceiptRuleSNSAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 encoding: Optional[str] = None,
                 topic_arn: Optional[str] = None):
        if encoding is not None:
            pulumi.set(__self__, "encoding", encoding)
        if topic_arn is not None:
            pulumi.set(__self__, "topic_arn", topic_arn)

    @property
    @pulumi.getter
    def encoding(self) -> Optional[str]:
        return pulumi.get(self, "encoding")

    @property
    @pulumi.getter(name="topicArn")
    def topic_arn(self) -> Optional[str]:
        return pulumi.get(self, "topic_arn")


@pulumi.output_type
class ReceiptRuleStopAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "topicArn":
            suggest = "topic_arn"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ReceiptRuleStopAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ReceiptRuleStopAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ReceiptRuleStopAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 scope: str,
                 topic_arn: Optional[str] = None):
        pulumi.set(__self__, "scope", scope)
        if topic_arn is not None:
            pulumi.set(__self__, "topic_arn", topic_arn)

    @property
    @pulumi.getter
    def scope(self) -> str:
        return pulumi.get(self, "scope")

    @property
    @pulumi.getter(name="topicArn")
    def topic_arn(self) -> Optional[str]:
        return pulumi.get(self, "topic_arn")


@pulumi.output_type
class ReceiptRuleWorkmailAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "organizationArn":
            suggest = "organization_arn"
        elif key == "topicArn":
            suggest = "topic_arn"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ReceiptRuleWorkmailAction. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ReceiptRuleWorkmailAction.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ReceiptRuleWorkmailAction.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 organization_arn: str,
                 topic_arn: Optional[str] = None):
        pulumi.set(__self__, "organization_arn", organization_arn)
        if topic_arn is not None:
            pulumi.set(__self__, "topic_arn", topic_arn)

    @property
    @pulumi.getter(name="organizationArn")
    def organization_arn(self) -> str:
        return pulumi.get(self, "organization_arn")

    @property
    @pulumi.getter(name="topicArn")
    def topic_arn(self) -> Optional[str]:
        return pulumi.get(self, "topic_arn")


@pulumi.output_type
class TemplateTemplate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "htmlPart":
            suggest = "html_part"
        elif key == "subjectPart":
            suggest = "subject_part"
        elif key == "templateName":
            suggest = "template_name"
        elif key == "textPart":
            suggest = "text_part"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in TemplateTemplate. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        TemplateTemplate.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        TemplateTemplate.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 html_part: Optional[str] = None,
                 subject_part: Optional[str] = None,
                 template_name: Optional[str] = None,
                 text_part: Optional[str] = None):
        if html_part is not None:
            pulumi.set(__self__, "html_part", html_part)
        if subject_part is not None:
            pulumi.set(__self__, "subject_part", subject_part)
        if template_name is not None:
            pulumi.set(__self__, "template_name", template_name)
        if text_part is not None:
            pulumi.set(__self__, "text_part", text_part)

    @property
    @pulumi.getter(name="htmlPart")
    def html_part(self) -> Optional[str]:
        return pulumi.get(self, "html_part")

    @property
    @pulumi.getter(name="subjectPart")
    def subject_part(self) -> Optional[str]:
        return pulumi.get(self, "subject_part")

    @property
    @pulumi.getter(name="templateName")
    def template_name(self) -> Optional[str]:
        return pulumi.get(self, "template_name")

    @property
    @pulumi.getter(name="textPart")
    def text_part(self) -> Optional[str]:
        return pulumi.get(self, "text_part")


