# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

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

__all__ = [
    'IndexingConfigurationThingGroupIndexingConfiguration',
    'IndexingConfigurationThingGroupIndexingConfigurationCustomField',
    'IndexingConfigurationThingGroupIndexingConfigurationManagedField',
    'IndexingConfigurationThingIndexingConfiguration',
    'IndexingConfigurationThingIndexingConfigurationCustomField',
    'IndexingConfigurationThingIndexingConfigurationManagedField',
    'ProvisioningTemplatePreProvisioningHook',
    'ThingGroupMetadata',
    'ThingGroupMetadataRootToParentGroup',
    'ThingGroupProperties',
    'ThingGroupPropertiesAttributePayload',
    'ThingTypeProperties',
    'TopicRuleCloudwatchAlarm',
    'TopicRuleCloudwatchLog',
    'TopicRuleCloudwatchMetric',
    'TopicRuleDestinationVpcConfiguration',
    'TopicRuleDynamodb',
    'TopicRuleDynamodbv2',
    'TopicRuleDynamodbv2PutItem',
    'TopicRuleElasticsearch',
    'TopicRuleErrorAction',
    'TopicRuleErrorActionCloudwatchAlarm',
    'TopicRuleErrorActionCloudwatchLogs',
    'TopicRuleErrorActionCloudwatchMetric',
    'TopicRuleErrorActionDynamodb',
    'TopicRuleErrorActionDynamodbv2',
    'TopicRuleErrorActionDynamodbv2PutItem',
    'TopicRuleErrorActionElasticsearch',
    'TopicRuleErrorActionFirehose',
    'TopicRuleErrorActionHttp',
    'TopicRuleErrorActionHttpHttpHeader',
    'TopicRuleErrorActionIotAnalytics',
    'TopicRuleErrorActionIotEvents',
    'TopicRuleErrorActionKafka',
    'TopicRuleErrorActionKinesis',
    'TopicRuleErrorActionLambda',
    'TopicRuleErrorActionRepublish',
    'TopicRuleErrorActionS3',
    'TopicRuleErrorActionSns',
    'TopicRuleErrorActionSqs',
    'TopicRuleErrorActionStepFunctions',
    'TopicRuleErrorActionTimestream',
    'TopicRuleErrorActionTimestreamDimension',
    'TopicRuleErrorActionTimestreamTimestamp',
    'TopicRuleFirehose',
    'TopicRuleHttp',
    'TopicRuleHttpHttpHeader',
    'TopicRuleIotAnalytic',
    'TopicRuleIotEvent',
    'TopicRuleKafka',
    'TopicRuleKinesis',
    'TopicRuleLambda',
    'TopicRuleRepublish',
    'TopicRuleS3',
    'TopicRuleSns',
    'TopicRuleSqs',
    'TopicRuleStepFunction',
    'TopicRuleTimestream',
    'TopicRuleTimestreamDimension',
    'TopicRuleTimestreamTimestamp',
]

@pulumi.output_type
class IndexingConfigurationThingGroupIndexingConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "thingGroupIndexingMode":
            suggest = "thing_group_indexing_mode"
        elif key == "customFields":
            suggest = "custom_fields"
        elif key == "managedFields":
            suggest = "managed_fields"

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

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

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

    def __init__(__self__, *,
                 thing_group_indexing_mode: str,
                 custom_fields: Optional[Sequence['outputs.IndexingConfigurationThingGroupIndexingConfigurationCustomField']] = None,
                 managed_fields: Optional[Sequence['outputs.IndexingConfigurationThingGroupIndexingConfigurationManagedField']] = None):
        """
        :param str thing_group_indexing_mode: Thing group indexing mode. Valid values: `OFF`, `ON`.
        :param Sequence['IndexingConfigurationThingGroupIndexingConfigurationCustomFieldArgs'] custom_fields: A list of thing group fields to index. This list cannot contain any managed fields. See below.
        :param Sequence['IndexingConfigurationThingGroupIndexingConfigurationManagedFieldArgs'] managed_fields: Contains fields that are indexed and whose types are already known by the Fleet Indexing service. See below.
        """
        pulumi.set(__self__, "thing_group_indexing_mode", thing_group_indexing_mode)
        if custom_fields is not None:
            pulumi.set(__self__, "custom_fields", custom_fields)
        if managed_fields is not None:
            pulumi.set(__self__, "managed_fields", managed_fields)

    @property
    @pulumi.getter(name="thingGroupIndexingMode")
    def thing_group_indexing_mode(self) -> str:
        """
        Thing group indexing mode. Valid values: `OFF`, `ON`.
        """
        return pulumi.get(self, "thing_group_indexing_mode")

    @property
    @pulumi.getter(name="customFields")
    def custom_fields(self) -> Optional[Sequence['outputs.IndexingConfigurationThingGroupIndexingConfigurationCustomField']]:
        """
        A list of thing group fields to index. This list cannot contain any managed fields. See below.
        """
        return pulumi.get(self, "custom_fields")

    @property
    @pulumi.getter(name="managedFields")
    def managed_fields(self) -> Optional[Sequence['outputs.IndexingConfigurationThingGroupIndexingConfigurationManagedField']]:
        """
        Contains fields that are indexed and whose types are already known by the Fleet Indexing service. See below.
        """
        return pulumi.get(self, "managed_fields")


@pulumi.output_type
class IndexingConfigurationThingGroupIndexingConfigurationCustomField(dict):
    def __init__(__self__, *,
                 name: Optional[str] = None,
                 type: Optional[str] = None):
        """
        :param str name: The name of the field.
        :param str type: The data type of the field. Valid values: `Number`, `String`, `Boolean`.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if type is not None:
            pulumi.set(__self__, "type", type)

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

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        The data type of the field. Valid values: `Number`, `String`, `Boolean`.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class IndexingConfigurationThingGroupIndexingConfigurationManagedField(dict):
    def __init__(__self__, *,
                 name: Optional[str] = None,
                 type: Optional[str] = None):
        """
        :param str name: The name of the field.
        :param str type: The data type of the field. Valid values: `Number`, `String`, `Boolean`.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if type is not None:
            pulumi.set(__self__, "type", type)

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

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        The data type of the field. Valid values: `Number`, `String`, `Boolean`.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class IndexingConfigurationThingIndexingConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "thingIndexingMode":
            suggest = "thing_indexing_mode"
        elif key == "customFields":
            suggest = "custom_fields"
        elif key == "deviceDefenderIndexingMode":
            suggest = "device_defender_indexing_mode"
        elif key == "managedFields":
            suggest = "managed_fields"
        elif key == "namedShadowIndexingMode":
            suggest = "named_shadow_indexing_mode"
        elif key == "thingConnectivityIndexingMode":
            suggest = "thing_connectivity_indexing_mode"

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

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

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

    def __init__(__self__, *,
                 thing_indexing_mode: str,
                 custom_fields: Optional[Sequence['outputs.IndexingConfigurationThingIndexingConfigurationCustomField']] = None,
                 device_defender_indexing_mode: Optional[str] = None,
                 managed_fields: Optional[Sequence['outputs.IndexingConfigurationThingIndexingConfigurationManagedField']] = None,
                 named_shadow_indexing_mode: Optional[str] = None,
                 thing_connectivity_indexing_mode: Optional[str] = None):
        """
        :param str thing_indexing_mode: Thing indexing mode. Valid values: `REGISTRY`, `REGISTRY_AND_SHADOW`, `OFF`.
        :param Sequence['IndexingConfigurationThingIndexingConfigurationCustomFieldArgs'] custom_fields: Contains custom field names and their data type. See below.
        :param str device_defender_indexing_mode: Device Defender indexing mode. Valid values: `VIOLATIONS`, `OFF`. Default: `OFF`.
        :param Sequence['IndexingConfigurationThingIndexingConfigurationManagedFieldArgs'] managed_fields: Contains fields that are indexed and whose types are already known by the Fleet Indexing service. See below.
        :param str named_shadow_indexing_mode: [Named shadow](https://docs.aws.amazon.com/iot/latest/developerguide/iot-device-shadows.html) indexing mode. Valid values: `ON`, `OFF`. Default: `OFF`.
        :param str thing_connectivity_indexing_mode: Thing connectivity indexing mode. Valid values: `STATUS`, `OFF`. Default: `OFF`.
        """
        pulumi.set(__self__, "thing_indexing_mode", thing_indexing_mode)
        if custom_fields is not None:
            pulumi.set(__self__, "custom_fields", custom_fields)
        if device_defender_indexing_mode is not None:
            pulumi.set(__self__, "device_defender_indexing_mode", device_defender_indexing_mode)
        if managed_fields is not None:
            pulumi.set(__self__, "managed_fields", managed_fields)
        if named_shadow_indexing_mode is not None:
            pulumi.set(__self__, "named_shadow_indexing_mode", named_shadow_indexing_mode)
        if thing_connectivity_indexing_mode is not None:
            pulumi.set(__self__, "thing_connectivity_indexing_mode", thing_connectivity_indexing_mode)

    @property
    @pulumi.getter(name="thingIndexingMode")
    def thing_indexing_mode(self) -> str:
        """
        Thing indexing mode. Valid values: `REGISTRY`, `REGISTRY_AND_SHADOW`, `OFF`.
        """
        return pulumi.get(self, "thing_indexing_mode")

    @property
    @pulumi.getter(name="customFields")
    def custom_fields(self) -> Optional[Sequence['outputs.IndexingConfigurationThingIndexingConfigurationCustomField']]:
        """
        Contains custom field names and their data type. See below.
        """
        return pulumi.get(self, "custom_fields")

    @property
    @pulumi.getter(name="deviceDefenderIndexingMode")
    def device_defender_indexing_mode(self) -> Optional[str]:
        """
        Device Defender indexing mode. Valid values: `VIOLATIONS`, `OFF`. Default: `OFF`.
        """
        return pulumi.get(self, "device_defender_indexing_mode")

    @property
    @pulumi.getter(name="managedFields")
    def managed_fields(self) -> Optional[Sequence['outputs.IndexingConfigurationThingIndexingConfigurationManagedField']]:
        """
        Contains fields that are indexed and whose types are already known by the Fleet Indexing service. See below.
        """
        return pulumi.get(self, "managed_fields")

    @property
    @pulumi.getter(name="namedShadowIndexingMode")
    def named_shadow_indexing_mode(self) -> Optional[str]:
        """
        [Named shadow](https://docs.aws.amazon.com/iot/latest/developerguide/iot-device-shadows.html) indexing mode. Valid values: `ON`, `OFF`. Default: `OFF`.
        """
        return pulumi.get(self, "named_shadow_indexing_mode")

    @property
    @pulumi.getter(name="thingConnectivityIndexingMode")
    def thing_connectivity_indexing_mode(self) -> Optional[str]:
        """
        Thing connectivity indexing mode. Valid values: `STATUS`, `OFF`. Default: `OFF`.
        """
        return pulumi.get(self, "thing_connectivity_indexing_mode")


@pulumi.output_type
class IndexingConfigurationThingIndexingConfigurationCustomField(dict):
    def __init__(__self__, *,
                 name: Optional[str] = None,
                 type: Optional[str] = None):
        """
        :param str name: The name of the field.
        :param str type: The data type of the field. Valid values: `Number`, `String`, `Boolean`.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if type is not None:
            pulumi.set(__self__, "type", type)

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

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        The data type of the field. Valid values: `Number`, `String`, `Boolean`.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class IndexingConfigurationThingIndexingConfigurationManagedField(dict):
    def __init__(__self__, *,
                 name: Optional[str] = None,
                 type: Optional[str] = None):
        """
        :param str name: The name of the field.
        :param str type: The data type of the field. Valid values: `Number`, `String`, `Boolean`.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if type is not None:
            pulumi.set(__self__, "type", type)

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

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        The data type of the field. Valid values: `Number`, `String`, `Boolean`.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class ProvisioningTemplatePreProvisioningHook(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "targetArn":
            suggest = "target_arn"
        elif key == "payloadVersion":
            suggest = "payload_version"

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

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

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

    def __init__(__self__, *,
                 target_arn: str,
                 payload_version: Optional[str] = None):
        """
        :param str payload_version: The version of the payload that was sent to the target function. The only valid (and the default) payload version is `"2020-04-01"`.
        """
        pulumi.set(__self__, "target_arn", target_arn)
        if payload_version is not None:
            pulumi.set(__self__, "payload_version", payload_version)

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

    @property
    @pulumi.getter(name="payloadVersion")
    def payload_version(self) -> Optional[str]:
        """
        The version of the payload that was sent to the target function. The only valid (and the default) payload version is `"2020-04-01"`.
        """
        return pulumi.get(self, "payload_version")


@pulumi.output_type
class ThingGroupMetadata(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "creationDate":
            suggest = "creation_date"
        elif key == "parentGroupName":
            suggest = "parent_group_name"
        elif key == "rootToParentGroups":
            suggest = "root_to_parent_groups"

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

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

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

    def __init__(__self__, *,
                 creation_date: Optional[str] = None,
                 parent_group_name: Optional[str] = None,
                 root_to_parent_groups: Optional[Sequence['outputs.ThingGroupMetadataRootToParentGroup']] = None):
        """
        :param str parent_group_name: The name of the parent Thing Group.
        """
        if creation_date is not None:
            pulumi.set(__self__, "creation_date", creation_date)
        if parent_group_name is not None:
            pulumi.set(__self__, "parent_group_name", parent_group_name)
        if root_to_parent_groups is not None:
            pulumi.set(__self__, "root_to_parent_groups", root_to_parent_groups)

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

    @property
    @pulumi.getter(name="parentGroupName")
    def parent_group_name(self) -> Optional[str]:
        """
        The name of the parent Thing Group.
        """
        return pulumi.get(self, "parent_group_name")

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


@pulumi.output_type
class ThingGroupMetadataRootToParentGroup(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "groupArn":
            suggest = "group_arn"
        elif key == "groupName":
            suggest = "group_name"

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

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

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

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

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

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


@pulumi.output_type
class ThingGroupProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "attributePayload":
            suggest = "attribute_payload"

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

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

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

    def __init__(__self__, *,
                 attribute_payload: Optional['outputs.ThingGroupPropertiesAttributePayload'] = None,
                 description: Optional[str] = None):
        """
        :param 'ThingGroupPropertiesAttributePayloadArgs' attribute_payload: The Thing Group attributes. Defined below.
        :param str description: A description of the Thing Group.
        """
        if attribute_payload is not None:
            pulumi.set(__self__, "attribute_payload", attribute_payload)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter(name="attributePayload")
    def attribute_payload(self) -> Optional['outputs.ThingGroupPropertiesAttributePayload']:
        """
        The Thing Group attributes. Defined below.
        """
        return pulumi.get(self, "attribute_payload")

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


@pulumi.output_type
class ThingGroupPropertiesAttributePayload(dict):
    def __init__(__self__, *,
                 attributes: Optional[Mapping[str, str]] = None):
        """
        :param Mapping[str, str] attributes: Key-value map.
        """
        if attributes is not None:
            pulumi.set(__self__, "attributes", attributes)

    @property
    @pulumi.getter
    def attributes(self) -> Optional[Mapping[str, str]]:
        """
        Key-value map.
        """
        return pulumi.get(self, "attributes")


@pulumi.output_type
class ThingTypeProperties(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "searchableAttributes":
            suggest = "searchable_attributes"

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

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

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

    def __init__(__self__, *,
                 description: Optional[str] = None,
                 searchable_attributes: Optional[Sequence[str]] = None):
        """
        :param str description: The description of the thing type.
        :param Sequence[str] searchable_attributes: A list of searchable thing attribute names.
        """
        if description is not None:
            pulumi.set(__self__, "description", description)
        if searchable_attributes is not None:
            pulumi.set(__self__, "searchable_attributes", searchable_attributes)

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

    @property
    @pulumi.getter(name="searchableAttributes")
    def searchable_attributes(self) -> Optional[Sequence[str]]:
        """
        A list of searchable thing attribute names.
        """
        return pulumi.get(self, "searchable_attributes")


@pulumi.output_type
class TopicRuleCloudwatchAlarm(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "alarmName":
            suggest = "alarm_name"
        elif key == "roleArn":
            suggest = "role_arn"
        elif key == "stateReason":
            suggest = "state_reason"
        elif key == "stateValue":
            suggest = "state_value"

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

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

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

    def __init__(__self__, *,
                 alarm_name: str,
                 role_arn: str,
                 state_reason: str,
                 state_value: str):
        """
        :param str alarm_name: The CloudWatch alarm name.
        :param str role_arn: The IAM role ARN that allows access to the CloudWatch alarm.
        :param str state_reason: The reason for the alarm change.
        :param str state_value: The value of the alarm state. Acceptable values are: OK, ALARM, INSUFFICIENT_DATA.
        """
        pulumi.set(__self__, "alarm_name", alarm_name)
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "state_reason", state_reason)
        pulumi.set(__self__, "state_value", state_value)

    @property
    @pulumi.getter(name="alarmName")
    def alarm_name(self) -> str:
        """
        The CloudWatch alarm name.
        """
        return pulumi.get(self, "alarm_name")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The IAM role ARN that allows access to the CloudWatch alarm.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="stateReason")
    def state_reason(self) -> str:
        """
        The reason for the alarm change.
        """
        return pulumi.get(self, "state_reason")

    @property
    @pulumi.getter(name="stateValue")
    def state_value(self) -> str:
        """
        The value of the alarm state. Acceptable values are: OK, ALARM, INSUFFICIENT_DATA.
        """
        return pulumi.get(self, "state_value")


@pulumi.output_type
class TopicRuleCloudwatchLog(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "logGroupName":
            suggest = "log_group_name"
        elif key == "roleArn":
            suggest = "role_arn"

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

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

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

    def __init__(__self__, *,
                 log_group_name: str,
                 role_arn: str):
        """
        :param str log_group_name: The CloudWatch log group name.
        :param str role_arn: The IAM role ARN that allows access to the CloudWatch alarm.
        """
        pulumi.set(__self__, "log_group_name", log_group_name)
        pulumi.set(__self__, "role_arn", role_arn)

    @property
    @pulumi.getter(name="logGroupName")
    def log_group_name(self) -> str:
        """
        The CloudWatch log group name.
        """
        return pulumi.get(self, "log_group_name")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The IAM role ARN that allows access to the CloudWatch alarm.
        """
        return pulumi.get(self, "role_arn")


@pulumi.output_type
class TopicRuleCloudwatchMetric(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "metricName":
            suggest = "metric_name"
        elif key == "metricNamespace":
            suggest = "metric_namespace"
        elif key == "metricUnit":
            suggest = "metric_unit"
        elif key == "metricValue":
            suggest = "metric_value"
        elif key == "roleArn":
            suggest = "role_arn"
        elif key == "metricTimestamp":
            suggest = "metric_timestamp"

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

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

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

    def __init__(__self__, *,
                 metric_name: str,
                 metric_namespace: str,
                 metric_unit: str,
                 metric_value: str,
                 role_arn: str,
                 metric_timestamp: Optional[str] = None):
        """
        :param str metric_name: The CloudWatch metric name.
        :param str metric_namespace: The CloudWatch metric namespace name.
        :param str metric_unit: The metric unit (supported units can be found here: http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/cloudwatch_concepts.html#Unit)
        :param str metric_value: The CloudWatch metric value.
        :param str role_arn: The IAM role ARN that allows access to the CloudWatch metric.
        :param str metric_timestamp: An optional Unix timestamp (http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/cloudwatch_concepts.html#about_timestamp).
        """
        pulumi.set(__self__, "metric_name", metric_name)
        pulumi.set(__self__, "metric_namespace", metric_namespace)
        pulumi.set(__self__, "metric_unit", metric_unit)
        pulumi.set(__self__, "metric_value", metric_value)
        pulumi.set(__self__, "role_arn", role_arn)
        if metric_timestamp is not None:
            pulumi.set(__self__, "metric_timestamp", metric_timestamp)

    @property
    @pulumi.getter(name="metricName")
    def metric_name(self) -> str:
        """
        The CloudWatch metric name.
        """
        return pulumi.get(self, "metric_name")

    @property
    @pulumi.getter(name="metricNamespace")
    def metric_namespace(self) -> str:
        """
        The CloudWatch metric namespace name.
        """
        return pulumi.get(self, "metric_namespace")

    @property
    @pulumi.getter(name="metricUnit")
    def metric_unit(self) -> str:
        """
        The metric unit (supported units can be found here: http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/cloudwatch_concepts.html#Unit)
        """
        return pulumi.get(self, "metric_unit")

    @property
    @pulumi.getter(name="metricValue")
    def metric_value(self) -> str:
        """
        The CloudWatch metric value.
        """
        return pulumi.get(self, "metric_value")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The IAM role ARN that allows access to the CloudWatch metric.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="metricTimestamp")
    def metric_timestamp(self) -> Optional[str]:
        """
        An optional Unix timestamp (http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/cloudwatch_concepts.html#about_timestamp).
        """
        return pulumi.get(self, "metric_timestamp")


@pulumi.output_type
class TopicRuleDestinationVpcConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "roleArn":
            suggest = "role_arn"
        elif key == "subnetIds":
            suggest = "subnet_ids"
        elif key == "vpcId":
            suggest = "vpc_id"
        elif key == "securityGroups":
            suggest = "security_groups"

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

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

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

    def __init__(__self__, *,
                 role_arn: str,
                 subnet_ids: Sequence[str],
                 vpc_id: str,
                 security_groups: Optional[Sequence[str]] = None):
        """
        :param str role_arn: The ARN of a role that has permission to create and attach to elastic network interfaces (ENIs).
        :param Sequence[str] subnet_ids: The subnet IDs of the VPC destination.
        :param str vpc_id: The ID of the VPC.
        :param Sequence[str] security_groups: The security groups of the VPC destination.
        """
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "subnet_ids", subnet_ids)
        pulumi.set(__self__, "vpc_id", vpc_id)
        if security_groups is not None:
            pulumi.set(__self__, "security_groups", security_groups)

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The ARN of a role that has permission to create and attach to elastic network interfaces (ENIs).
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="subnetIds")
    def subnet_ids(self) -> Sequence[str]:
        """
        The subnet IDs of the VPC destination.
        """
        return pulumi.get(self, "subnet_ids")

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> str:
        """
        The ID of the VPC.
        """
        return pulumi.get(self, "vpc_id")

    @property
    @pulumi.getter(name="securityGroups")
    def security_groups(self) -> Optional[Sequence[str]]:
        """
        The security groups of the VPC destination.
        """
        return pulumi.get(self, "security_groups")


@pulumi.output_type
class TopicRuleDynamodb(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hashKeyField":
            suggest = "hash_key_field"
        elif key == "hashKeyValue":
            suggest = "hash_key_value"
        elif key == "roleArn":
            suggest = "role_arn"
        elif key == "tableName":
            suggest = "table_name"
        elif key == "hashKeyType":
            suggest = "hash_key_type"
        elif key == "payloadField":
            suggest = "payload_field"
        elif key == "rangeKeyField":
            suggest = "range_key_field"
        elif key == "rangeKeyType":
            suggest = "range_key_type"
        elif key == "rangeKeyValue":
            suggest = "range_key_value"

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

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

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

    def __init__(__self__, *,
                 hash_key_field: str,
                 hash_key_value: str,
                 role_arn: str,
                 table_name: str,
                 hash_key_type: Optional[str] = None,
                 operation: Optional[str] = None,
                 payload_field: Optional[str] = None,
                 range_key_field: Optional[str] = None,
                 range_key_type: Optional[str] = None,
                 range_key_value: Optional[str] = None):
        """
        :param str hash_key_field: The hash key name.
        :param str hash_key_value: The hash key value.
        :param str role_arn: The ARN of the IAM role that grants access to the DynamoDB table.
        :param str table_name: The name of the DynamoDB table.
        :param str hash_key_type: The hash key type. Valid values are "STRING" or "NUMBER".
        :param str operation: The operation. Valid values are "INSERT", "UPDATE", or "DELETE".
        :param str payload_field: The action payload.
        :param str range_key_field: The range key name.
        :param str range_key_type: The range key type. Valid values are "STRING" or "NUMBER".
        :param str range_key_value: The range key value.
        """
        pulumi.set(__self__, "hash_key_field", hash_key_field)
        pulumi.set(__self__, "hash_key_value", hash_key_value)
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "table_name", table_name)
        if hash_key_type is not None:
            pulumi.set(__self__, "hash_key_type", hash_key_type)
        if operation is not None:
            pulumi.set(__self__, "operation", operation)
        if payload_field is not None:
            pulumi.set(__self__, "payload_field", payload_field)
        if range_key_field is not None:
            pulumi.set(__self__, "range_key_field", range_key_field)
        if range_key_type is not None:
            pulumi.set(__self__, "range_key_type", range_key_type)
        if range_key_value is not None:
            pulumi.set(__self__, "range_key_value", range_key_value)

    @property
    @pulumi.getter(name="hashKeyField")
    def hash_key_field(self) -> str:
        """
        The hash key name.
        """
        return pulumi.get(self, "hash_key_field")

    @property
    @pulumi.getter(name="hashKeyValue")
    def hash_key_value(self) -> str:
        """
        The hash key value.
        """
        return pulumi.get(self, "hash_key_value")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The ARN of the IAM role that grants access to the DynamoDB table.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="tableName")
    def table_name(self) -> str:
        """
        The name of the DynamoDB table.
        """
        return pulumi.get(self, "table_name")

    @property
    @pulumi.getter(name="hashKeyType")
    def hash_key_type(self) -> Optional[str]:
        """
        The hash key type. Valid values are "STRING" or "NUMBER".
        """
        return pulumi.get(self, "hash_key_type")

    @property
    @pulumi.getter
    def operation(self) -> Optional[str]:
        """
        The operation. Valid values are "INSERT", "UPDATE", or "DELETE".
        """
        return pulumi.get(self, "operation")

    @property
    @pulumi.getter(name="payloadField")
    def payload_field(self) -> Optional[str]:
        """
        The action payload.
        """
        return pulumi.get(self, "payload_field")

    @property
    @pulumi.getter(name="rangeKeyField")
    def range_key_field(self) -> Optional[str]:
        """
        The range key name.
        """
        return pulumi.get(self, "range_key_field")

    @property
    @pulumi.getter(name="rangeKeyType")
    def range_key_type(self) -> Optional[str]:
        """
        The range key type. Valid values are "STRING" or "NUMBER".
        """
        return pulumi.get(self, "range_key_type")

    @property
    @pulumi.getter(name="rangeKeyValue")
    def range_key_value(self) -> Optional[str]:
        """
        The range key value.
        """
        return pulumi.get(self, "range_key_value")


@pulumi.output_type
class TopicRuleDynamodbv2(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "roleArn":
            suggest = "role_arn"
        elif key == "putItem":
            suggest = "put_item"

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

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

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

    def __init__(__self__, *,
                 role_arn: str,
                 put_item: Optional['outputs.TopicRuleDynamodbv2PutItem'] = None):
        """
        :param str role_arn: The IAM role ARN that allows access to the CloudWatch alarm.
        :param 'TopicRuleDynamodbv2PutItemArgs' put_item: Configuration block with DynamoDB Table to which the message will be written. Nested arguments below.
        """
        pulumi.set(__self__, "role_arn", role_arn)
        if put_item is not None:
            pulumi.set(__self__, "put_item", put_item)

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The IAM role ARN that allows access to the CloudWatch alarm.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="putItem")
    def put_item(self) -> Optional['outputs.TopicRuleDynamodbv2PutItem']:
        """
        Configuration block with DynamoDB Table to which the message will be written. Nested arguments below.
        """
        return pulumi.get(self, "put_item")


@pulumi.output_type
class TopicRuleDynamodbv2PutItem(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "tableName":
            suggest = "table_name"

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

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

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

    def __init__(__self__, *,
                 table_name: str):
        """
        :param str table_name: The name of the DynamoDB table.
        """
        pulumi.set(__self__, "table_name", table_name)

    @property
    @pulumi.getter(name="tableName")
    def table_name(self) -> str:
        """
        The name of the DynamoDB table.
        """
        return pulumi.get(self, "table_name")


@pulumi.output_type
class TopicRuleElasticsearch(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "roleArn":
            suggest = "role_arn"

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

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

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

    def __init__(__self__, *,
                 endpoint: str,
                 id: str,
                 index: str,
                 role_arn: str,
                 type: str):
        """
        :param str endpoint: The endpoint of your Elasticsearch domain.
        :param str id: The unique identifier for the document you are storing.
        :param str index: The Elasticsearch index where you want to store your data.
        :param str role_arn: The IAM role ARN that has access to Elasticsearch.
        :param str type: The type of document you are storing.
        """
        pulumi.set(__self__, "endpoint", endpoint)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "index", index)
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def endpoint(self) -> str:
        """
        The endpoint of your Elasticsearch domain.
        """
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The unique identifier for the document you are storing.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def index(self) -> str:
        """
        The Elasticsearch index where you want to store your data.
        """
        return pulumi.get(self, "index")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The IAM role ARN that has access to Elasticsearch.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of document you are storing.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class TopicRuleErrorAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cloudwatchAlarm":
            suggest = "cloudwatch_alarm"
        elif key == "cloudwatchLogs":
            suggest = "cloudwatch_logs"
        elif key == "cloudwatchMetric":
            suggest = "cloudwatch_metric"
        elif key == "iotAnalytics":
            suggest = "iot_analytics"
        elif key == "iotEvents":
            suggest = "iot_events"
        elif key == "lambda":
            suggest = "lambda_"
        elif key == "stepFunctions":
            suggest = "step_functions"

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

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

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

    def __init__(__self__, *,
                 cloudwatch_alarm: Optional['outputs.TopicRuleErrorActionCloudwatchAlarm'] = None,
                 cloudwatch_logs: Optional['outputs.TopicRuleErrorActionCloudwatchLogs'] = None,
                 cloudwatch_metric: Optional['outputs.TopicRuleErrorActionCloudwatchMetric'] = None,
                 dynamodb: Optional['outputs.TopicRuleErrorActionDynamodb'] = None,
                 dynamodbv2: Optional['outputs.TopicRuleErrorActionDynamodbv2'] = None,
                 elasticsearch: Optional['outputs.TopicRuleErrorActionElasticsearch'] = None,
                 firehose: Optional['outputs.TopicRuleErrorActionFirehose'] = None,
                 http: Optional['outputs.TopicRuleErrorActionHttp'] = None,
                 iot_analytics: Optional['outputs.TopicRuleErrorActionIotAnalytics'] = None,
                 iot_events: Optional['outputs.TopicRuleErrorActionIotEvents'] = None,
                 kafka: Optional['outputs.TopicRuleErrorActionKafka'] = None,
                 kinesis: Optional['outputs.TopicRuleErrorActionKinesis'] = None,
                 lambda_: Optional['outputs.TopicRuleErrorActionLambda'] = None,
                 republish: Optional['outputs.TopicRuleErrorActionRepublish'] = None,
                 s3: Optional['outputs.TopicRuleErrorActionS3'] = None,
                 sns: Optional['outputs.TopicRuleErrorActionSns'] = None,
                 sqs: Optional['outputs.TopicRuleErrorActionSqs'] = None,
                 step_functions: Optional['outputs.TopicRuleErrorActionStepFunctions'] = None,
                 timestream: Optional['outputs.TopicRuleErrorActionTimestream'] = None):
        if cloudwatch_alarm is not None:
            pulumi.set(__self__, "cloudwatch_alarm", cloudwatch_alarm)
        if cloudwatch_logs is not None:
            pulumi.set(__self__, "cloudwatch_logs", cloudwatch_logs)
        if cloudwatch_metric is not None:
            pulumi.set(__self__, "cloudwatch_metric", cloudwatch_metric)
        if dynamodb is not None:
            pulumi.set(__self__, "dynamodb", dynamodb)
        if dynamodbv2 is not None:
            pulumi.set(__self__, "dynamodbv2", dynamodbv2)
        if elasticsearch is not None:
            pulumi.set(__self__, "elasticsearch", elasticsearch)
        if firehose is not None:
            pulumi.set(__self__, "firehose", firehose)
        if http is not None:
            pulumi.set(__self__, "http", http)
        if iot_analytics is not None:
            pulumi.set(__self__, "iot_analytics", iot_analytics)
        if iot_events is not None:
            pulumi.set(__self__, "iot_events", iot_events)
        if kafka is not None:
            pulumi.set(__self__, "kafka", kafka)
        if kinesis is not None:
            pulumi.set(__self__, "kinesis", kinesis)
        if lambda_ is not None:
            pulumi.set(__self__, "lambda_", lambda_)
        if republish is not None:
            pulumi.set(__self__, "republish", republish)
        if s3 is not None:
            pulumi.set(__self__, "s3", s3)
        if sns is not None:
            pulumi.set(__self__, "sns", sns)
        if sqs is not None:
            pulumi.set(__self__, "sqs", sqs)
        if step_functions is not None:
            pulumi.set(__self__, "step_functions", step_functions)
        if timestream is not None:
            pulumi.set(__self__, "timestream", timestream)

    @property
    @pulumi.getter(name="cloudwatchAlarm")
    def cloudwatch_alarm(self) -> Optional['outputs.TopicRuleErrorActionCloudwatchAlarm']:
        return pulumi.get(self, "cloudwatch_alarm")

    @property
    @pulumi.getter(name="cloudwatchLogs")
    def cloudwatch_logs(self) -> Optional['outputs.TopicRuleErrorActionCloudwatchLogs']:
        return pulumi.get(self, "cloudwatch_logs")

    @property
    @pulumi.getter(name="cloudwatchMetric")
    def cloudwatch_metric(self) -> Optional['outputs.TopicRuleErrorActionCloudwatchMetric']:
        return pulumi.get(self, "cloudwatch_metric")

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

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

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

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

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

    @property
    @pulumi.getter(name="iotAnalytics")
    def iot_analytics(self) -> Optional['outputs.TopicRuleErrorActionIotAnalytics']:
        return pulumi.get(self, "iot_analytics")

    @property
    @pulumi.getter(name="iotEvents")
    def iot_events(self) -> Optional['outputs.TopicRuleErrorActionIotEvents']:
        return pulumi.get(self, "iot_events")

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

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

    @property
    @pulumi.getter(name="lambda")
    def lambda_(self) -> Optional['outputs.TopicRuleErrorActionLambda']:
        return pulumi.get(self, "lambda_")

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

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

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

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

    @property
    @pulumi.getter(name="stepFunctions")
    def step_functions(self) -> Optional['outputs.TopicRuleErrorActionStepFunctions']:
        return pulumi.get(self, "step_functions")

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


@pulumi.output_type
class TopicRuleErrorActionCloudwatchAlarm(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "alarmName":
            suggest = "alarm_name"
        elif key == "roleArn":
            suggest = "role_arn"
        elif key == "stateReason":
            suggest = "state_reason"
        elif key == "stateValue":
            suggest = "state_value"

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

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

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

    def __init__(__self__, *,
                 alarm_name: str,
                 role_arn: str,
                 state_reason: str,
                 state_value: str):
        """
        :param str alarm_name: The CloudWatch alarm name.
        :param str role_arn: The IAM role ARN that allows access to the CloudWatch alarm.
        :param str state_reason: The reason for the alarm change.
        :param str state_value: The value of the alarm state. Acceptable values are: OK, ALARM, INSUFFICIENT_DATA.
        """
        pulumi.set(__self__, "alarm_name", alarm_name)
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "state_reason", state_reason)
        pulumi.set(__self__, "state_value", state_value)

    @property
    @pulumi.getter(name="alarmName")
    def alarm_name(self) -> str:
        """
        The CloudWatch alarm name.
        """
        return pulumi.get(self, "alarm_name")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The IAM role ARN that allows access to the CloudWatch alarm.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="stateReason")
    def state_reason(self) -> str:
        """
        The reason for the alarm change.
        """
        return pulumi.get(self, "state_reason")

    @property
    @pulumi.getter(name="stateValue")
    def state_value(self) -> str:
        """
        The value of the alarm state. Acceptable values are: OK, ALARM, INSUFFICIENT_DATA.
        """
        return pulumi.get(self, "state_value")


@pulumi.output_type
class TopicRuleErrorActionCloudwatchLogs(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "logGroupName":
            suggest = "log_group_name"
        elif key == "roleArn":
            suggest = "role_arn"

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

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

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

    def __init__(__self__, *,
                 log_group_name: str,
                 role_arn: str):
        """
        :param str log_group_name: The CloudWatch log group name.
        :param str role_arn: The IAM role ARN that allows access to the CloudWatch alarm.
        """
        pulumi.set(__self__, "log_group_name", log_group_name)
        pulumi.set(__self__, "role_arn", role_arn)

    @property
    @pulumi.getter(name="logGroupName")
    def log_group_name(self) -> str:
        """
        The CloudWatch log group name.
        """
        return pulumi.get(self, "log_group_name")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The IAM role ARN that allows access to the CloudWatch alarm.
        """
        return pulumi.get(self, "role_arn")


@pulumi.output_type
class TopicRuleErrorActionCloudwatchMetric(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "metricName":
            suggest = "metric_name"
        elif key == "metricNamespace":
            suggest = "metric_namespace"
        elif key == "metricUnit":
            suggest = "metric_unit"
        elif key == "metricValue":
            suggest = "metric_value"
        elif key == "roleArn":
            suggest = "role_arn"
        elif key == "metricTimestamp":
            suggest = "metric_timestamp"

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

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

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

    def __init__(__self__, *,
                 metric_name: str,
                 metric_namespace: str,
                 metric_unit: str,
                 metric_value: str,
                 role_arn: str,
                 metric_timestamp: Optional[str] = None):
        """
        :param str metric_name: The CloudWatch metric name.
        :param str metric_namespace: The CloudWatch metric namespace name.
        :param str metric_unit: The metric unit (supported units can be found here: http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/cloudwatch_concepts.html#Unit)
        :param str metric_value: The CloudWatch metric value.
        :param str role_arn: The IAM role ARN that allows access to the CloudWatch metric.
        :param str metric_timestamp: An optional Unix timestamp (http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/cloudwatch_concepts.html#about_timestamp).
        """
        pulumi.set(__self__, "metric_name", metric_name)
        pulumi.set(__self__, "metric_namespace", metric_namespace)
        pulumi.set(__self__, "metric_unit", metric_unit)
        pulumi.set(__self__, "metric_value", metric_value)
        pulumi.set(__self__, "role_arn", role_arn)
        if metric_timestamp is not None:
            pulumi.set(__self__, "metric_timestamp", metric_timestamp)

    @property
    @pulumi.getter(name="metricName")
    def metric_name(self) -> str:
        """
        The CloudWatch metric name.
        """
        return pulumi.get(self, "metric_name")

    @property
    @pulumi.getter(name="metricNamespace")
    def metric_namespace(self) -> str:
        """
        The CloudWatch metric namespace name.
        """
        return pulumi.get(self, "metric_namespace")

    @property
    @pulumi.getter(name="metricUnit")
    def metric_unit(self) -> str:
        """
        The metric unit (supported units can be found here: http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/cloudwatch_concepts.html#Unit)
        """
        return pulumi.get(self, "metric_unit")

    @property
    @pulumi.getter(name="metricValue")
    def metric_value(self) -> str:
        """
        The CloudWatch metric value.
        """
        return pulumi.get(self, "metric_value")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The IAM role ARN that allows access to the CloudWatch metric.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="metricTimestamp")
    def metric_timestamp(self) -> Optional[str]:
        """
        An optional Unix timestamp (http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/cloudwatch_concepts.html#about_timestamp).
        """
        return pulumi.get(self, "metric_timestamp")


@pulumi.output_type
class TopicRuleErrorActionDynamodb(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "hashKeyField":
            suggest = "hash_key_field"
        elif key == "hashKeyValue":
            suggest = "hash_key_value"
        elif key == "roleArn":
            suggest = "role_arn"
        elif key == "tableName":
            suggest = "table_name"
        elif key == "hashKeyType":
            suggest = "hash_key_type"
        elif key == "payloadField":
            suggest = "payload_field"
        elif key == "rangeKeyField":
            suggest = "range_key_field"
        elif key == "rangeKeyType":
            suggest = "range_key_type"
        elif key == "rangeKeyValue":
            suggest = "range_key_value"

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

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

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

    def __init__(__self__, *,
                 hash_key_field: str,
                 hash_key_value: str,
                 role_arn: str,
                 table_name: str,
                 hash_key_type: Optional[str] = None,
                 operation: Optional[str] = None,
                 payload_field: Optional[str] = None,
                 range_key_field: Optional[str] = None,
                 range_key_type: Optional[str] = None,
                 range_key_value: Optional[str] = None):
        """
        :param str hash_key_field: The hash key name.
        :param str hash_key_value: The hash key value.
        :param str role_arn: The ARN of the IAM role that grants access to the DynamoDB table.
        :param str table_name: The name of the DynamoDB table.
        :param str hash_key_type: The hash key type. Valid values are "STRING" or "NUMBER".
        :param str operation: The operation. Valid values are "INSERT", "UPDATE", or "DELETE".
        :param str payload_field: The action payload.
        :param str range_key_field: The range key name.
        :param str range_key_type: The range key type. Valid values are "STRING" or "NUMBER".
        :param str range_key_value: The range key value.
        """
        pulumi.set(__self__, "hash_key_field", hash_key_field)
        pulumi.set(__self__, "hash_key_value", hash_key_value)
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "table_name", table_name)
        if hash_key_type is not None:
            pulumi.set(__self__, "hash_key_type", hash_key_type)
        if operation is not None:
            pulumi.set(__self__, "operation", operation)
        if payload_field is not None:
            pulumi.set(__self__, "payload_field", payload_field)
        if range_key_field is not None:
            pulumi.set(__self__, "range_key_field", range_key_field)
        if range_key_type is not None:
            pulumi.set(__self__, "range_key_type", range_key_type)
        if range_key_value is not None:
            pulumi.set(__self__, "range_key_value", range_key_value)

    @property
    @pulumi.getter(name="hashKeyField")
    def hash_key_field(self) -> str:
        """
        The hash key name.
        """
        return pulumi.get(self, "hash_key_field")

    @property
    @pulumi.getter(name="hashKeyValue")
    def hash_key_value(self) -> str:
        """
        The hash key value.
        """
        return pulumi.get(self, "hash_key_value")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The ARN of the IAM role that grants access to the DynamoDB table.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="tableName")
    def table_name(self) -> str:
        """
        The name of the DynamoDB table.
        """
        return pulumi.get(self, "table_name")

    @property
    @pulumi.getter(name="hashKeyType")
    def hash_key_type(self) -> Optional[str]:
        """
        The hash key type. Valid values are "STRING" or "NUMBER".
        """
        return pulumi.get(self, "hash_key_type")

    @property
    @pulumi.getter
    def operation(self) -> Optional[str]:
        """
        The operation. Valid values are "INSERT", "UPDATE", or "DELETE".
        """
        return pulumi.get(self, "operation")

    @property
    @pulumi.getter(name="payloadField")
    def payload_field(self) -> Optional[str]:
        """
        The action payload.
        """
        return pulumi.get(self, "payload_field")

    @property
    @pulumi.getter(name="rangeKeyField")
    def range_key_field(self) -> Optional[str]:
        """
        The range key name.
        """
        return pulumi.get(self, "range_key_field")

    @property
    @pulumi.getter(name="rangeKeyType")
    def range_key_type(self) -> Optional[str]:
        """
        The range key type. Valid values are "STRING" or "NUMBER".
        """
        return pulumi.get(self, "range_key_type")

    @property
    @pulumi.getter(name="rangeKeyValue")
    def range_key_value(self) -> Optional[str]:
        """
        The range key value.
        """
        return pulumi.get(self, "range_key_value")


@pulumi.output_type
class TopicRuleErrorActionDynamodbv2(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "roleArn":
            suggest = "role_arn"
        elif key == "putItem":
            suggest = "put_item"

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

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

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

    def __init__(__self__, *,
                 role_arn: str,
                 put_item: Optional['outputs.TopicRuleErrorActionDynamodbv2PutItem'] = None):
        """
        :param str role_arn: The IAM role ARN that allows access to the CloudWatch alarm.
        :param 'TopicRuleErrorActionDynamodbv2PutItemArgs' put_item: Configuration block with DynamoDB Table to which the message will be written. Nested arguments below.
        """
        pulumi.set(__self__, "role_arn", role_arn)
        if put_item is not None:
            pulumi.set(__self__, "put_item", put_item)

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The IAM role ARN that allows access to the CloudWatch alarm.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="putItem")
    def put_item(self) -> Optional['outputs.TopicRuleErrorActionDynamodbv2PutItem']:
        """
        Configuration block with DynamoDB Table to which the message will be written. Nested arguments below.
        """
        return pulumi.get(self, "put_item")


@pulumi.output_type
class TopicRuleErrorActionDynamodbv2PutItem(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "tableName":
            suggest = "table_name"

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

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

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

    def __init__(__self__, *,
                 table_name: str):
        """
        :param str table_name: The name of the DynamoDB table.
        """
        pulumi.set(__self__, "table_name", table_name)

    @property
    @pulumi.getter(name="tableName")
    def table_name(self) -> str:
        """
        The name of the DynamoDB table.
        """
        return pulumi.get(self, "table_name")


@pulumi.output_type
class TopicRuleErrorActionElasticsearch(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "roleArn":
            suggest = "role_arn"

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

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

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

    def __init__(__self__, *,
                 endpoint: str,
                 id: str,
                 index: str,
                 role_arn: str,
                 type: str):
        """
        :param str endpoint: The endpoint of your Elasticsearch domain.
        :param str id: The unique identifier for the document you are storing.
        :param str index: The Elasticsearch index where you want to store your data.
        :param str role_arn: The IAM role ARN that has access to Elasticsearch.
        :param str type: The type of document you are storing.
        """
        pulumi.set(__self__, "endpoint", endpoint)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "index", index)
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def endpoint(self) -> str:
        """
        The endpoint of your Elasticsearch domain.
        """
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        The unique identifier for the document you are storing.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def index(self) -> str:
        """
        The Elasticsearch index where you want to store your data.
        """
        return pulumi.get(self, "index")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The IAM role ARN that has access to Elasticsearch.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter
    def type(self) -> str:
        """
        The type of document you are storing.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class TopicRuleErrorActionFirehose(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deliveryStreamName":
            suggest = "delivery_stream_name"
        elif key == "roleArn":
            suggest = "role_arn"

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

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

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

    def __init__(__self__, *,
                 delivery_stream_name: str,
                 role_arn: str,
                 separator: Optional[str] = None):
        """
        :param str delivery_stream_name: The delivery stream name.
        :param str role_arn: The IAM role ARN that grants access to the Amazon Kinesis Firehose stream.
        :param str separator: A character separator that is used to separate records written to the Firehose stream. Valid values are: '\\n' (newline), '\\t' (tab), '\\r\\n' (Windows newline), ',' (comma).
        """
        pulumi.set(__self__, "delivery_stream_name", delivery_stream_name)
        pulumi.set(__self__, "role_arn", role_arn)
        if separator is not None:
            pulumi.set(__self__, "separator", separator)

    @property
    @pulumi.getter(name="deliveryStreamName")
    def delivery_stream_name(self) -> str:
        """
        The delivery stream name.
        """
        return pulumi.get(self, "delivery_stream_name")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The IAM role ARN that grants access to the Amazon Kinesis Firehose stream.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter
    def separator(self) -> Optional[str]:
        """
        A character separator that is used to separate records written to the Firehose stream. Valid values are: '\\n' (newline), '\\t' (tab), '\\r\\n' (Windows newline), ',' (comma).
        """
        return pulumi.get(self, "separator")


@pulumi.output_type
class TopicRuleErrorActionHttp(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "confirmationUrl":
            suggest = "confirmation_url"
        elif key == "httpHeaders":
            suggest = "http_headers"

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

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

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

    def __init__(__self__, *,
                 url: str,
                 confirmation_url: Optional[str] = None,
                 http_headers: Optional[Sequence['outputs.TopicRuleErrorActionHttpHttpHeader']] = None):
        """
        :param str url: The HTTPS URL.
        :param str confirmation_url: The HTTPS URL used to verify ownership of `url`.
        :param Sequence['TopicRuleErrorActionHttpHttpHeaderArgs'] http_headers: Custom HTTP header IoT Core should send. It is possible to define more than one custom header.
        """
        pulumi.set(__self__, "url", url)
        if confirmation_url is not None:
            pulumi.set(__self__, "confirmation_url", confirmation_url)
        if http_headers is not None:
            pulumi.set(__self__, "http_headers", http_headers)

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        The HTTPS URL.
        """
        return pulumi.get(self, "url")

    @property
    @pulumi.getter(name="confirmationUrl")
    def confirmation_url(self) -> Optional[str]:
        """
        The HTTPS URL used to verify ownership of `url`.
        """
        return pulumi.get(self, "confirmation_url")

    @property
    @pulumi.getter(name="httpHeaders")
    def http_headers(self) -> Optional[Sequence['outputs.TopicRuleErrorActionHttpHttpHeader']]:
        """
        Custom HTTP header IoT Core should send. It is possible to define more than one custom header.
        """
        return pulumi.get(self, "http_headers")


@pulumi.output_type
class TopicRuleErrorActionHttpHttpHeader(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        """
        :param str key: The name of the HTTP header.
        :param str value: The value of the HTTP header.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The name of the HTTP header.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        The value of the HTTP header.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class TopicRuleErrorActionIotAnalytics(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "channelName":
            suggest = "channel_name"
        elif key == "roleArn":
            suggest = "role_arn"

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

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

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

    def __init__(__self__, *,
                 channel_name: str,
                 role_arn: str):
        """
        :param str channel_name: Name of AWS IOT Analytics channel.
        :param str role_arn: The ARN of the IAM role that grants access.
        """
        pulumi.set(__self__, "channel_name", channel_name)
        pulumi.set(__self__, "role_arn", role_arn)

    @property
    @pulumi.getter(name="channelName")
    def channel_name(self) -> str:
        """
        Name of AWS IOT Analytics channel.
        """
        return pulumi.get(self, "channel_name")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The ARN of the IAM role that grants access.
        """
        return pulumi.get(self, "role_arn")


@pulumi.output_type
class TopicRuleErrorActionIotEvents(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "inputName":
            suggest = "input_name"
        elif key == "roleArn":
            suggest = "role_arn"
        elif key == "messageId":
            suggest = "message_id"

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

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

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

    def __init__(__self__, *,
                 input_name: str,
                 role_arn: str,
                 message_id: Optional[str] = None):
        """
        :param str input_name: The name of the AWS IoT Events input.
        :param str role_arn: The ARN of the IAM role that grants access.
        :param str message_id: Use this to ensure that only one input (message) with a given messageId is processed by an AWS IoT Events detector.
        """
        pulumi.set(__self__, "input_name", input_name)
        pulumi.set(__self__, "role_arn", role_arn)
        if message_id is not None:
            pulumi.set(__self__, "message_id", message_id)

    @property
    @pulumi.getter(name="inputName")
    def input_name(self) -> str:
        """
        The name of the AWS IoT Events input.
        """
        return pulumi.get(self, "input_name")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The ARN of the IAM role that grants access.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="messageId")
    def message_id(self) -> Optional[str]:
        """
        Use this to ensure that only one input (message) with a given messageId is processed by an AWS IoT Events detector.
        """
        return pulumi.get(self, "message_id")


@pulumi.output_type
class TopicRuleErrorActionKafka(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientProperties":
            suggest = "client_properties"
        elif key == "destinationArn":
            suggest = "destination_arn"

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

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

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

    def __init__(__self__, *,
                 client_properties: Mapping[str, str],
                 destination_arn: str,
                 topic: str,
                 key: Optional[str] = None,
                 partition: Optional[str] = None):
        """
        :param Mapping[str, str] client_properties: Properties of the Apache Kafka producer client. For more info, see the [AWS documentation](https://docs.aws.amazon.com/iot/latest/developerguide/apache-kafka-rule-action.html).
        :param str destination_arn: The ARN of Kafka action's VPC `iot.TopicRuleDestination` .
        :param str topic: The Kafka topic for messages to be sent to the Kafka broker.
        :param str key: The Kafka message key.
        :param str partition: The Kafka message partition.
        """
        pulumi.set(__self__, "client_properties", client_properties)
        pulumi.set(__self__, "destination_arn", destination_arn)
        pulumi.set(__self__, "topic", topic)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if partition is not None:
            pulumi.set(__self__, "partition", partition)

    @property
    @pulumi.getter(name="clientProperties")
    def client_properties(self) -> Mapping[str, str]:
        """
        Properties of the Apache Kafka producer client. For more info, see the [AWS documentation](https://docs.aws.amazon.com/iot/latest/developerguide/apache-kafka-rule-action.html).
        """
        return pulumi.get(self, "client_properties")

    @property
    @pulumi.getter(name="destinationArn")
    def destination_arn(self) -> str:
        """
        The ARN of Kafka action's VPC `iot.TopicRuleDestination` .
        """
        return pulumi.get(self, "destination_arn")

    @property
    @pulumi.getter
    def topic(self) -> str:
        """
        The Kafka topic for messages to be sent to the Kafka broker.
        """
        return pulumi.get(self, "topic")

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

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


@pulumi.output_type
class TopicRuleErrorActionKinesis(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "roleArn":
            suggest = "role_arn"
        elif key == "streamName":
            suggest = "stream_name"
        elif key == "partitionKey":
            suggest = "partition_key"

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

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

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

    def __init__(__self__, *,
                 role_arn: str,
                 stream_name: str,
                 partition_key: Optional[str] = None):
        """
        :param str role_arn: The ARN of the IAM role that grants access to the Amazon Kinesis stream.
        :param str stream_name: The name of the Amazon Kinesis stream.
        :param str partition_key: The partition key.
        """
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "stream_name", stream_name)
        if partition_key is not None:
            pulumi.set(__self__, "partition_key", partition_key)

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The ARN of the IAM role that grants access to the Amazon Kinesis stream.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="streamName")
    def stream_name(self) -> str:
        """
        The name of the Amazon Kinesis stream.
        """
        return pulumi.get(self, "stream_name")

    @property
    @pulumi.getter(name="partitionKey")
    def partition_key(self) -> Optional[str]:
        """
        The partition key.
        """
        return pulumi.get(self, "partition_key")


@pulumi.output_type
class TopicRuleErrorActionLambda(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "functionArn":
            suggest = "function_arn"

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

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

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

    def __init__(__self__, *,
                 function_arn: str):
        """
        :param str function_arn: The ARN of the Lambda function.
        """
        pulumi.set(__self__, "function_arn", function_arn)

    @property
    @pulumi.getter(name="functionArn")
    def function_arn(self) -> str:
        """
        The ARN of the Lambda function.
        """
        return pulumi.get(self, "function_arn")


@pulumi.output_type
class TopicRuleErrorActionRepublish(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "roleArn":
            suggest = "role_arn"

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

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

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

    def __init__(__self__, *,
                 role_arn: str,
                 topic: str,
                 qos: Optional[int] = None):
        """
        :param str role_arn: The ARN of the IAM role that grants access.
        :param str topic: The name of the MQTT topic the message should be republished to.
        :param int qos: The Quality of Service (QoS) level to use when republishing messages. Valid values are 0 or 1. The default value is 0.
        """
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "topic", topic)
        if qos is not None:
            pulumi.set(__self__, "qos", qos)

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The ARN of the IAM role that grants access.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter
    def topic(self) -> str:
        """
        The name of the MQTT topic the message should be republished to.
        """
        return pulumi.get(self, "topic")

    @property
    @pulumi.getter
    def qos(self) -> Optional[int]:
        """
        The Quality of Service (QoS) level to use when republishing messages. Valid values are 0 or 1. The default value is 0.
        """
        return pulumi.get(self, "qos")


@pulumi.output_type
class TopicRuleErrorActionS3(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bucketName":
            suggest = "bucket_name"
        elif key == "roleArn":
            suggest = "role_arn"
        elif key == "cannedAcl":
            suggest = "canned_acl"

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

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

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

    def __init__(__self__, *,
                 bucket_name: str,
                 key: str,
                 role_arn: str,
                 canned_acl: Optional[str] = None):
        """
        :param str bucket_name: The Amazon S3 bucket name.
        :param str key: The name of the HTTP header.
        :param str role_arn: The IAM role ARN that allows access to the CloudWatch alarm.
        :param str canned_acl: The Amazon S3 canned ACL that controls access to the object identified by the object key. [Valid values](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html#canned-acl).
        """
        pulumi.set(__self__, "bucket_name", bucket_name)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "role_arn", role_arn)
        if canned_acl is not None:
            pulumi.set(__self__, "canned_acl", canned_acl)

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

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The name of the HTTP header.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The IAM role ARN that allows access to the CloudWatch alarm.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="cannedAcl")
    def canned_acl(self) -> Optional[str]:
        """
        The Amazon S3 canned ACL that controls access to the object identified by the object key. [Valid values](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html#canned-acl).
        """
        return pulumi.get(self, "canned_acl")


@pulumi.output_type
class TopicRuleErrorActionSns(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "roleArn":
            suggest = "role_arn"
        elif key == "targetArn":
            suggest = "target_arn"
        elif key == "messageFormat":
            suggest = "message_format"

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

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

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

    def __init__(__self__, *,
                 role_arn: str,
                 target_arn: str,
                 message_format: Optional[str] = None):
        """
        :param str role_arn: The ARN of the IAM role that grants access.
        :param str target_arn: The ARN of the SNS topic.
        :param str message_format: The message format of the message to publish. Accepted values are "JSON" and "RAW".
        """
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "target_arn", target_arn)
        if message_format is not None:
            pulumi.set(__self__, "message_format", message_format)

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The ARN of the IAM role that grants access.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="targetArn")
    def target_arn(self) -> str:
        """
        The ARN of the SNS topic.
        """
        return pulumi.get(self, "target_arn")

    @property
    @pulumi.getter(name="messageFormat")
    def message_format(self) -> Optional[str]:
        """
        The message format of the message to publish. Accepted values are "JSON" and "RAW".
        """
        return pulumi.get(self, "message_format")


@pulumi.output_type
class TopicRuleErrorActionSqs(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "queueUrl":
            suggest = "queue_url"
        elif key == "roleArn":
            suggest = "role_arn"
        elif key == "useBase64":
            suggest = "use_base64"

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

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

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

    def __init__(__self__, *,
                 queue_url: str,
                 role_arn: str,
                 use_base64: bool):
        """
        :param str queue_url: The URL of the Amazon SQS queue.
        :param str role_arn: The ARN of the IAM role that grants access.
        :param bool use_base64: Specifies whether to use Base64 encoding.
        """
        pulumi.set(__self__, "queue_url", queue_url)
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "use_base64", use_base64)

    @property
    @pulumi.getter(name="queueUrl")
    def queue_url(self) -> str:
        """
        The URL of the Amazon SQS queue.
        """
        return pulumi.get(self, "queue_url")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The ARN of the IAM role that grants access.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="useBase64")
    def use_base64(self) -> bool:
        """
        Specifies whether to use Base64 encoding.
        """
        return pulumi.get(self, "use_base64")


@pulumi.output_type
class TopicRuleErrorActionStepFunctions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "roleArn":
            suggest = "role_arn"
        elif key == "stateMachineName":
            suggest = "state_machine_name"
        elif key == "executionNamePrefix":
            suggest = "execution_name_prefix"

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

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

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

    def __init__(__self__, *,
                 role_arn: str,
                 state_machine_name: str,
                 execution_name_prefix: Optional[str] = None):
        """
        :param str role_arn: The ARN of the IAM role that grants access to start execution of the state machine.
        :param str state_machine_name: The name of the Step Functions state machine whose execution will be started.
        :param str execution_name_prefix: The prefix used to generate, along with a UUID, the unique state machine execution name.
        """
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "state_machine_name", state_machine_name)
        if execution_name_prefix is not None:
            pulumi.set(__self__, "execution_name_prefix", execution_name_prefix)

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The ARN of the IAM role that grants access to start execution of the state machine.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="stateMachineName")
    def state_machine_name(self) -> str:
        """
        The name of the Step Functions state machine whose execution will be started.
        """
        return pulumi.get(self, "state_machine_name")

    @property
    @pulumi.getter(name="executionNamePrefix")
    def execution_name_prefix(self) -> Optional[str]:
        """
        The prefix used to generate, along with a UUID, the unique state machine execution name.
        """
        return pulumi.get(self, "execution_name_prefix")


@pulumi.output_type
class TopicRuleErrorActionTimestream(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "roleArn":
            suggest = "role_arn"
        elif key == "tableName":
            suggest = "table_name"

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

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

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

    def __init__(__self__, *,
                 database_name: str,
                 dimensions: Sequence['outputs.TopicRuleErrorActionTimestreamDimension'],
                 role_arn: str,
                 table_name: str,
                 timestamp: Optional['outputs.TopicRuleErrorActionTimestreamTimestamp'] = None):
        """
        :param str database_name: The name of an Amazon Timestream database.
        :param Sequence['TopicRuleErrorActionTimestreamDimensionArgs'] dimensions: Configuration blocks with metadata attributes of the time series that are written in each measure record. Nested arguments below.
        :param str role_arn: The ARN of the role that grants permission to write to the Amazon Timestream database table.
        :param str table_name: The name of the database table into which to write the measure records.
        :param 'TopicRuleErrorActionTimestreamTimestampArgs' timestamp: Configuration block specifying an application-defined value to replace the default value assigned to the Timestream record's timestamp in the time column. Nested arguments below.
        """
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "dimensions", dimensions)
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "table_name", table_name)
        if timestamp is not None:
            pulumi.set(__self__, "timestamp", timestamp)

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        The name of an Amazon Timestream database.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def dimensions(self) -> Sequence['outputs.TopicRuleErrorActionTimestreamDimension']:
        """
        Configuration blocks with metadata attributes of the time series that are written in each measure record. Nested arguments below.
        """
        return pulumi.get(self, "dimensions")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The ARN of the role that grants permission to write to the Amazon Timestream database table.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="tableName")
    def table_name(self) -> str:
        """
        The name of the database table into which to write the measure records.
        """
        return pulumi.get(self, "table_name")

    @property
    @pulumi.getter
    def timestamp(self) -> Optional['outputs.TopicRuleErrorActionTimestreamTimestamp']:
        """
        Configuration block specifying an application-defined value to replace the default value assigned to the Timestream record's timestamp in the time column. Nested arguments below.
        """
        return pulumi.get(self, "timestamp")


@pulumi.output_type
class TopicRuleErrorActionTimestreamDimension(dict):
    def __init__(__self__, *,
                 name: str,
                 value: str):
        """
        :param str name: The name of the rule.
        :param str value: The value of the HTTP header.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

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

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        The value of the HTTP header.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class TopicRuleErrorActionTimestreamTimestamp(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: str):
        """
        :param str unit: The precision of the timestamp value that results from the expression described in value. Valid values: `SECONDS`, `MILLISECONDS`, `MICROSECONDS`, `NANOSECONDS`.
        :param str value: The value of the HTTP header.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        """
        The precision of the timestamp value that results from the expression described in value. Valid values: `SECONDS`, `MILLISECONDS`, `MICROSECONDS`, `NANOSECONDS`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        The value of the HTTP header.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class TopicRuleFirehose(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deliveryStreamName":
            suggest = "delivery_stream_name"
        elif key == "roleArn":
            suggest = "role_arn"

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

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

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

    def __init__(__self__, *,
                 delivery_stream_name: str,
                 role_arn: str,
                 separator: Optional[str] = None):
        """
        :param str delivery_stream_name: The delivery stream name.
        :param str role_arn: The IAM role ARN that grants access to the Amazon Kinesis Firehose stream.
        :param str separator: A character separator that is used to separate records written to the Firehose stream. Valid values are: '\\n' (newline), '\\t' (tab), '\\r\\n' (Windows newline), ',' (comma).
        """
        pulumi.set(__self__, "delivery_stream_name", delivery_stream_name)
        pulumi.set(__self__, "role_arn", role_arn)
        if separator is not None:
            pulumi.set(__self__, "separator", separator)

    @property
    @pulumi.getter(name="deliveryStreamName")
    def delivery_stream_name(self) -> str:
        """
        The delivery stream name.
        """
        return pulumi.get(self, "delivery_stream_name")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The IAM role ARN that grants access to the Amazon Kinesis Firehose stream.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter
    def separator(self) -> Optional[str]:
        """
        A character separator that is used to separate records written to the Firehose stream. Valid values are: '\\n' (newline), '\\t' (tab), '\\r\\n' (Windows newline), ',' (comma).
        """
        return pulumi.get(self, "separator")


@pulumi.output_type
class TopicRuleHttp(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "confirmationUrl":
            suggest = "confirmation_url"
        elif key == "httpHeaders":
            suggest = "http_headers"

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

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

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

    def __init__(__self__, *,
                 url: str,
                 confirmation_url: Optional[str] = None,
                 http_headers: Optional[Sequence['outputs.TopicRuleHttpHttpHeader']] = None):
        """
        :param str url: The HTTPS URL.
        :param str confirmation_url: The HTTPS URL used to verify ownership of `url`.
        :param Sequence['TopicRuleHttpHttpHeaderArgs'] http_headers: Custom HTTP header IoT Core should send. It is possible to define more than one custom header.
        """
        pulumi.set(__self__, "url", url)
        if confirmation_url is not None:
            pulumi.set(__self__, "confirmation_url", confirmation_url)
        if http_headers is not None:
            pulumi.set(__self__, "http_headers", http_headers)

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        The HTTPS URL.
        """
        return pulumi.get(self, "url")

    @property
    @pulumi.getter(name="confirmationUrl")
    def confirmation_url(self) -> Optional[str]:
        """
        The HTTPS URL used to verify ownership of `url`.
        """
        return pulumi.get(self, "confirmation_url")

    @property
    @pulumi.getter(name="httpHeaders")
    def http_headers(self) -> Optional[Sequence['outputs.TopicRuleHttpHttpHeader']]:
        """
        Custom HTTP header IoT Core should send. It is possible to define more than one custom header.
        """
        return pulumi.get(self, "http_headers")


@pulumi.output_type
class TopicRuleHttpHttpHeader(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        """
        :param str key: The name of the HTTP header.
        :param str value: The value of the HTTP header.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The name of the HTTP header.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        The value of the HTTP header.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class TopicRuleIotAnalytic(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "channelName":
            suggest = "channel_name"
        elif key == "roleArn":
            suggest = "role_arn"

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

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

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

    def __init__(__self__, *,
                 channel_name: str,
                 role_arn: str):
        """
        :param str channel_name: Name of AWS IOT Analytics channel.
        :param str role_arn: The ARN of the IAM role that grants access.
        """
        pulumi.set(__self__, "channel_name", channel_name)
        pulumi.set(__self__, "role_arn", role_arn)

    @property
    @pulumi.getter(name="channelName")
    def channel_name(self) -> str:
        """
        Name of AWS IOT Analytics channel.
        """
        return pulumi.get(self, "channel_name")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The ARN of the IAM role that grants access.
        """
        return pulumi.get(self, "role_arn")


@pulumi.output_type
class TopicRuleIotEvent(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "inputName":
            suggest = "input_name"
        elif key == "roleArn":
            suggest = "role_arn"
        elif key == "messageId":
            suggest = "message_id"

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

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

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

    def __init__(__self__, *,
                 input_name: str,
                 role_arn: str,
                 message_id: Optional[str] = None):
        """
        :param str input_name: The name of the AWS IoT Events input.
        :param str role_arn: The ARN of the IAM role that grants access.
        :param str message_id: Use this to ensure that only one input (message) with a given messageId is processed by an AWS IoT Events detector.
        """
        pulumi.set(__self__, "input_name", input_name)
        pulumi.set(__self__, "role_arn", role_arn)
        if message_id is not None:
            pulumi.set(__self__, "message_id", message_id)

    @property
    @pulumi.getter(name="inputName")
    def input_name(self) -> str:
        """
        The name of the AWS IoT Events input.
        """
        return pulumi.get(self, "input_name")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The ARN of the IAM role that grants access.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="messageId")
    def message_id(self) -> Optional[str]:
        """
        Use this to ensure that only one input (message) with a given messageId is processed by an AWS IoT Events detector.
        """
        return pulumi.get(self, "message_id")


@pulumi.output_type
class TopicRuleKafka(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientProperties":
            suggest = "client_properties"
        elif key == "destinationArn":
            suggest = "destination_arn"

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

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

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

    def __init__(__self__, *,
                 client_properties: Mapping[str, str],
                 destination_arn: str,
                 topic: str,
                 key: Optional[str] = None,
                 partition: Optional[str] = None):
        """
        :param Mapping[str, str] client_properties: Properties of the Apache Kafka producer client. For more info, see the [AWS documentation](https://docs.aws.amazon.com/iot/latest/developerguide/apache-kafka-rule-action.html).
        :param str destination_arn: The ARN of Kafka action's VPC `iot.TopicRuleDestination` .
        :param str topic: The Kafka topic for messages to be sent to the Kafka broker.
        :param str key: The Kafka message key.
        :param str partition: The Kafka message partition.
        """
        pulumi.set(__self__, "client_properties", client_properties)
        pulumi.set(__self__, "destination_arn", destination_arn)
        pulumi.set(__self__, "topic", topic)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if partition is not None:
            pulumi.set(__self__, "partition", partition)

    @property
    @pulumi.getter(name="clientProperties")
    def client_properties(self) -> Mapping[str, str]:
        """
        Properties of the Apache Kafka producer client. For more info, see the [AWS documentation](https://docs.aws.amazon.com/iot/latest/developerguide/apache-kafka-rule-action.html).
        """
        return pulumi.get(self, "client_properties")

    @property
    @pulumi.getter(name="destinationArn")
    def destination_arn(self) -> str:
        """
        The ARN of Kafka action's VPC `iot.TopicRuleDestination` .
        """
        return pulumi.get(self, "destination_arn")

    @property
    @pulumi.getter
    def topic(self) -> str:
        """
        The Kafka topic for messages to be sent to the Kafka broker.
        """
        return pulumi.get(self, "topic")

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

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


@pulumi.output_type
class TopicRuleKinesis(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "roleArn":
            suggest = "role_arn"
        elif key == "streamName":
            suggest = "stream_name"
        elif key == "partitionKey":
            suggest = "partition_key"

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

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

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

    def __init__(__self__, *,
                 role_arn: str,
                 stream_name: str,
                 partition_key: Optional[str] = None):
        """
        :param str role_arn: The ARN of the IAM role that grants access to the Amazon Kinesis stream.
        :param str stream_name: The name of the Amazon Kinesis stream.
        :param str partition_key: The partition key.
        """
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "stream_name", stream_name)
        if partition_key is not None:
            pulumi.set(__self__, "partition_key", partition_key)

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The ARN of the IAM role that grants access to the Amazon Kinesis stream.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="streamName")
    def stream_name(self) -> str:
        """
        The name of the Amazon Kinesis stream.
        """
        return pulumi.get(self, "stream_name")

    @property
    @pulumi.getter(name="partitionKey")
    def partition_key(self) -> Optional[str]:
        """
        The partition key.
        """
        return pulumi.get(self, "partition_key")


@pulumi.output_type
class TopicRuleLambda(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "functionArn":
            suggest = "function_arn"

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

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

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

    def __init__(__self__, *,
                 function_arn: str):
        """
        :param str function_arn: The ARN of the Lambda function.
        """
        pulumi.set(__self__, "function_arn", function_arn)

    @property
    @pulumi.getter(name="functionArn")
    def function_arn(self) -> str:
        """
        The ARN of the Lambda function.
        """
        return pulumi.get(self, "function_arn")


@pulumi.output_type
class TopicRuleRepublish(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "roleArn":
            suggest = "role_arn"

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

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

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

    def __init__(__self__, *,
                 role_arn: str,
                 topic: str,
                 qos: Optional[int] = None):
        """
        :param str role_arn: The ARN of the IAM role that grants access.
        :param str topic: The name of the MQTT topic the message should be republished to.
        :param int qos: The Quality of Service (QoS) level to use when republishing messages. Valid values are 0 or 1. The default value is 0.
        """
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "topic", topic)
        if qos is not None:
            pulumi.set(__self__, "qos", qos)

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The ARN of the IAM role that grants access.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter
    def topic(self) -> str:
        """
        The name of the MQTT topic the message should be republished to.
        """
        return pulumi.get(self, "topic")

    @property
    @pulumi.getter
    def qos(self) -> Optional[int]:
        """
        The Quality of Service (QoS) level to use when republishing messages. Valid values are 0 or 1. The default value is 0.
        """
        return pulumi.get(self, "qos")


@pulumi.output_type
class TopicRuleS3(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bucketName":
            suggest = "bucket_name"
        elif key == "roleArn":
            suggest = "role_arn"
        elif key == "cannedAcl":
            suggest = "canned_acl"

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

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

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

    def __init__(__self__, *,
                 bucket_name: str,
                 key: str,
                 role_arn: str,
                 canned_acl: Optional[str] = None):
        """
        :param str bucket_name: The Amazon S3 bucket name.
        :param str key: The name of the HTTP header.
        :param str role_arn: The IAM role ARN that allows access to the CloudWatch alarm.
        :param str canned_acl: The Amazon S3 canned ACL that controls access to the object identified by the object key. [Valid values](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html#canned-acl).
        """
        pulumi.set(__self__, "bucket_name", bucket_name)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "role_arn", role_arn)
        if canned_acl is not None:
            pulumi.set(__self__, "canned_acl", canned_acl)

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

    @property
    @pulumi.getter
    def key(self) -> str:
        """
        The name of the HTTP header.
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The IAM role ARN that allows access to the CloudWatch alarm.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="cannedAcl")
    def canned_acl(self) -> Optional[str]:
        """
        The Amazon S3 canned ACL that controls access to the object identified by the object key. [Valid values](https://docs.aws.amazon.com/AmazonS3/latest/userguide/acl-overview.html#canned-acl).
        """
        return pulumi.get(self, "canned_acl")


@pulumi.output_type
class TopicRuleSns(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "roleArn":
            suggest = "role_arn"
        elif key == "targetArn":
            suggest = "target_arn"
        elif key == "messageFormat":
            suggest = "message_format"

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

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

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

    def __init__(__self__, *,
                 role_arn: str,
                 target_arn: str,
                 message_format: Optional[str] = None):
        """
        :param str role_arn: The ARN of the IAM role that grants access.
        :param str target_arn: The ARN of the SNS topic.
        :param str message_format: The message format of the message to publish. Accepted values are "JSON" and "RAW".
        """
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "target_arn", target_arn)
        if message_format is not None:
            pulumi.set(__self__, "message_format", message_format)

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The ARN of the IAM role that grants access.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="targetArn")
    def target_arn(self) -> str:
        """
        The ARN of the SNS topic.
        """
        return pulumi.get(self, "target_arn")

    @property
    @pulumi.getter(name="messageFormat")
    def message_format(self) -> Optional[str]:
        """
        The message format of the message to publish. Accepted values are "JSON" and "RAW".
        """
        return pulumi.get(self, "message_format")


@pulumi.output_type
class TopicRuleSqs(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "queueUrl":
            suggest = "queue_url"
        elif key == "roleArn":
            suggest = "role_arn"
        elif key == "useBase64":
            suggest = "use_base64"

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

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

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

    def __init__(__self__, *,
                 queue_url: str,
                 role_arn: str,
                 use_base64: bool):
        """
        :param str queue_url: The URL of the Amazon SQS queue.
        :param str role_arn: The ARN of the IAM role that grants access.
        :param bool use_base64: Specifies whether to use Base64 encoding.
        """
        pulumi.set(__self__, "queue_url", queue_url)
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "use_base64", use_base64)

    @property
    @pulumi.getter(name="queueUrl")
    def queue_url(self) -> str:
        """
        The URL of the Amazon SQS queue.
        """
        return pulumi.get(self, "queue_url")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The ARN of the IAM role that grants access.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="useBase64")
    def use_base64(self) -> bool:
        """
        Specifies whether to use Base64 encoding.
        """
        return pulumi.get(self, "use_base64")


@pulumi.output_type
class TopicRuleStepFunction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "roleArn":
            suggest = "role_arn"
        elif key == "stateMachineName":
            suggest = "state_machine_name"
        elif key == "executionNamePrefix":
            suggest = "execution_name_prefix"

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

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

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

    def __init__(__self__, *,
                 role_arn: str,
                 state_machine_name: str,
                 execution_name_prefix: Optional[str] = None):
        """
        :param str role_arn: The ARN of the IAM role that grants access to start execution of the state machine.
        :param str state_machine_name: The name of the Step Functions state machine whose execution will be started.
        :param str execution_name_prefix: The prefix used to generate, along with a UUID, the unique state machine execution name.
        """
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "state_machine_name", state_machine_name)
        if execution_name_prefix is not None:
            pulumi.set(__self__, "execution_name_prefix", execution_name_prefix)

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The ARN of the IAM role that grants access to start execution of the state machine.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="stateMachineName")
    def state_machine_name(self) -> str:
        """
        The name of the Step Functions state machine whose execution will be started.
        """
        return pulumi.get(self, "state_machine_name")

    @property
    @pulumi.getter(name="executionNamePrefix")
    def execution_name_prefix(self) -> Optional[str]:
        """
        The prefix used to generate, along with a UUID, the unique state machine execution name.
        """
        return pulumi.get(self, "execution_name_prefix")


@pulumi.output_type
class TopicRuleTimestream(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "databaseName":
            suggest = "database_name"
        elif key == "roleArn":
            suggest = "role_arn"
        elif key == "tableName":
            suggest = "table_name"

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

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

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

    def __init__(__self__, *,
                 database_name: str,
                 dimensions: Sequence['outputs.TopicRuleTimestreamDimension'],
                 role_arn: str,
                 table_name: str,
                 timestamp: Optional['outputs.TopicRuleTimestreamTimestamp'] = None):
        """
        :param str database_name: The name of an Amazon Timestream database.
        :param Sequence['TopicRuleTimestreamDimensionArgs'] dimensions: Configuration blocks with metadata attributes of the time series that are written in each measure record. Nested arguments below.
        :param str role_arn: The ARN of the role that grants permission to write to the Amazon Timestream database table.
        :param str table_name: The name of the database table into which to write the measure records.
        :param 'TopicRuleTimestreamTimestampArgs' timestamp: Configuration block specifying an application-defined value to replace the default value assigned to the Timestream record's timestamp in the time column. Nested arguments below.
        """
        pulumi.set(__self__, "database_name", database_name)
        pulumi.set(__self__, "dimensions", dimensions)
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "table_name", table_name)
        if timestamp is not None:
            pulumi.set(__self__, "timestamp", timestamp)

    @property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> str:
        """
        The name of an Amazon Timestream database.
        """
        return pulumi.get(self, "database_name")

    @property
    @pulumi.getter
    def dimensions(self) -> Sequence['outputs.TopicRuleTimestreamDimension']:
        """
        Configuration blocks with metadata attributes of the time series that are written in each measure record. Nested arguments below.
        """
        return pulumi.get(self, "dimensions")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        """
        The ARN of the role that grants permission to write to the Amazon Timestream database table.
        """
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="tableName")
    def table_name(self) -> str:
        """
        The name of the database table into which to write the measure records.
        """
        return pulumi.get(self, "table_name")

    @property
    @pulumi.getter
    def timestamp(self) -> Optional['outputs.TopicRuleTimestreamTimestamp']:
        """
        Configuration block specifying an application-defined value to replace the default value assigned to the Timestream record's timestamp in the time column. Nested arguments below.
        """
        return pulumi.get(self, "timestamp")


@pulumi.output_type
class TopicRuleTimestreamDimension(dict):
    def __init__(__self__, *,
                 name: str,
                 value: str):
        """
        :param str name: The name of the rule.
        :param str value: The value of the HTTP header.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

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

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        The value of the HTTP header.
        """
        return pulumi.get(self, "value")


@pulumi.output_type
class TopicRuleTimestreamTimestamp(dict):
    def __init__(__self__, *,
                 unit: str,
                 value: str):
        """
        :param str unit: The precision of the timestamp value that results from the expression described in value. Valid values: `SECONDS`, `MILLISECONDS`, `MICROSECONDS`, `NANOSECONDS`.
        :param str value: The value of the HTTP header.
        """
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def unit(self) -> str:
        """
        The precision of the timestamp value that results from the expression described in value. Valid values: `SECONDS`, `MILLISECONDS`, `MICROSECONDS`, `NANOSECONDS`.
        """
        return pulumi.get(self, "unit")

    @property
    @pulumi.getter
    def value(self) -> str:
        """
        The value of the HTTP header.
        """
        return pulumi.get(self, "value")


