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

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

__all__ = [
    'AccountAuditConfigurationAuditCheckConfigurationsArgs',
    'AccountAuditConfigurationAuditCheckConfigurationArgs',
    'AccountAuditConfigurationAuditNotificationTargetConfigurationsArgs',
    'AccountAuditConfigurationAuditNotificationTargetArgs',
    'AuthorizerTagArgs',
    'CustomMetricTagArgs',
    'DimensionTagArgs',
    'DomainConfigurationAuthorizerConfigArgs',
    'DomainConfigurationTagArgs',
    'FleetMetricAggregationTypeArgs',
    'FleetMetricTagArgs',
    'MitigationActionActionParamsArgs',
    'MitigationActionAddThingsToThingGroupParamsArgs',
    'MitigationActionEnableIoTLoggingParamsArgs',
    'MitigationActionPublishFindingToSnsParamsArgs',
    'MitigationActionReplaceDefaultPolicyVersionParamsArgs',
    'MitigationActionTagArgs',
    'MitigationActionUpdateCACertificateParamsArgs',
    'MitigationActionUpdateDeviceCertificateParamsArgs',
    'ProvisioningTemplateProvisioningHookArgs',
    'ProvisioningTemplateTagArgs',
    'ScheduledAuditTagArgs',
    'SecurityProfileBehaviorCriteriaArgs',
    'SecurityProfileBehaviorArgs',
    'SecurityProfileMachineLearningDetectionConfigArgs',
    'SecurityProfileMetricDimensionArgs',
    'SecurityProfileMetricToRetainArgs',
    'SecurityProfileMetricValueArgs',
    'SecurityProfileStatisticalThresholdArgs',
    'SecurityProfileTagArgs',
    'ThingAttributePayloadArgs',
    'TopicRuleActionArgs',
    'TopicRuleAssetPropertyTimestampArgs',
    'TopicRuleAssetPropertyValueArgs',
    'TopicRuleAssetPropertyVariantArgs',
    'TopicRuleCloudwatchAlarmActionArgs',
    'TopicRuleCloudwatchLogsActionArgs',
    'TopicRuleCloudwatchMetricActionArgs',
    'TopicRuleDestinationHttpUrlDestinationSummaryArgs',
    'TopicRuleDestinationVpcDestinationPropertiesArgs',
    'TopicRuleDynamoDBActionArgs',
    'TopicRuleDynamoDBv2ActionArgs',
    'TopicRuleElasticsearchActionArgs',
    'TopicRuleFirehoseActionArgs',
    'TopicRuleHttpActionHeaderArgs',
    'TopicRuleHttpActionArgs',
    'TopicRuleHttpAuthorizationArgs',
    'TopicRuleIotAnalyticsActionArgs',
    'TopicRuleIotEventsActionArgs',
    'TopicRuleIotSiteWiseActionArgs',
    'TopicRuleKafkaActionArgs',
    'TopicRuleKinesisActionArgs',
    'TopicRuleLambdaActionArgs',
    'TopicRuleOpenSearchActionArgs',
    'TopicRulePutAssetPropertyValueEntryArgs',
    'TopicRulePutItemInputArgs',
    'TopicRuleRepublishActionArgs',
    'TopicRuleS3ActionArgs',
    'TopicRuleSigV4AuthorizationArgs',
    'TopicRuleSnsActionArgs',
    'TopicRuleSqsActionArgs',
    'TopicRuleStepFunctionsActionArgs',
    'TopicRuleTagArgs',
    'TopicRuleTimestreamActionArgs',
    'TopicRuleTimestreamDimensionArgs',
    'TopicRuleTimestreamTimestampArgs',
    'TopicRuleTopicRulePayloadArgs',
]

@pulumi.input_type
class AccountAuditConfigurationAuditCheckConfigurationsArgs:
    def __init__(__self__, *,
                 authenticated_cognito_role_overly_permissive_check: Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']] = None,
                 ca_certificate_expiring_check: Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']] = None,
                 ca_certificate_key_quality_check: Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']] = None,
                 conflicting_client_ids_check: Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']] = None,
                 device_certificate_expiring_check: Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']] = None,
                 device_certificate_key_quality_check: Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']] = None,
                 device_certificate_shared_check: Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']] = None,
                 iot_policy_overly_permissive_check: Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']] = None,
                 iot_role_alias_allows_access_to_unused_services_check: Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']] = None,
                 iot_role_alias_overly_permissive_check: Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']] = None,
                 logging_disabled_check: Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']] = None,
                 revoked_ca_certificate_still_active_check: Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']] = None,
                 revoked_device_certificate_still_active_check: Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']] = None,
                 unauthenticated_cognito_role_overly_permissive_check: Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']] = None):
        """
        Specifies which audit checks are enabled and disabled for this account.
        """
        if authenticated_cognito_role_overly_permissive_check is not None:
            pulumi.set(__self__, "authenticated_cognito_role_overly_permissive_check", authenticated_cognito_role_overly_permissive_check)
        if ca_certificate_expiring_check is not None:
            pulumi.set(__self__, "ca_certificate_expiring_check", ca_certificate_expiring_check)
        if ca_certificate_key_quality_check is not None:
            pulumi.set(__self__, "ca_certificate_key_quality_check", ca_certificate_key_quality_check)
        if conflicting_client_ids_check is not None:
            pulumi.set(__self__, "conflicting_client_ids_check", conflicting_client_ids_check)
        if device_certificate_expiring_check is not None:
            pulumi.set(__self__, "device_certificate_expiring_check", device_certificate_expiring_check)
        if device_certificate_key_quality_check is not None:
            pulumi.set(__self__, "device_certificate_key_quality_check", device_certificate_key_quality_check)
        if device_certificate_shared_check is not None:
            pulumi.set(__self__, "device_certificate_shared_check", device_certificate_shared_check)
        if iot_policy_overly_permissive_check is not None:
            pulumi.set(__self__, "iot_policy_overly_permissive_check", iot_policy_overly_permissive_check)
        if iot_role_alias_allows_access_to_unused_services_check is not None:
            pulumi.set(__self__, "iot_role_alias_allows_access_to_unused_services_check", iot_role_alias_allows_access_to_unused_services_check)
        if iot_role_alias_overly_permissive_check is not None:
            pulumi.set(__self__, "iot_role_alias_overly_permissive_check", iot_role_alias_overly_permissive_check)
        if logging_disabled_check is not None:
            pulumi.set(__self__, "logging_disabled_check", logging_disabled_check)
        if revoked_ca_certificate_still_active_check is not None:
            pulumi.set(__self__, "revoked_ca_certificate_still_active_check", revoked_ca_certificate_still_active_check)
        if revoked_device_certificate_still_active_check is not None:
            pulumi.set(__self__, "revoked_device_certificate_still_active_check", revoked_device_certificate_still_active_check)
        if unauthenticated_cognito_role_overly_permissive_check is not None:
            pulumi.set(__self__, "unauthenticated_cognito_role_overly_permissive_check", unauthenticated_cognito_role_overly_permissive_check)

    @property
    @pulumi.getter(name="authenticatedCognitoRoleOverlyPermissiveCheck")
    def authenticated_cognito_role_overly_permissive_check(self) -> Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']]:
        return pulumi.get(self, "authenticated_cognito_role_overly_permissive_check")

    @authenticated_cognito_role_overly_permissive_check.setter
    def authenticated_cognito_role_overly_permissive_check(self, value: Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']]):
        pulumi.set(self, "authenticated_cognito_role_overly_permissive_check", value)

    @property
    @pulumi.getter(name="caCertificateExpiringCheck")
    def ca_certificate_expiring_check(self) -> Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']]:
        return pulumi.get(self, "ca_certificate_expiring_check")

    @ca_certificate_expiring_check.setter
    def ca_certificate_expiring_check(self, value: Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']]):
        pulumi.set(self, "ca_certificate_expiring_check", value)

    @property
    @pulumi.getter(name="caCertificateKeyQualityCheck")
    def ca_certificate_key_quality_check(self) -> Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']]:
        return pulumi.get(self, "ca_certificate_key_quality_check")

    @ca_certificate_key_quality_check.setter
    def ca_certificate_key_quality_check(self, value: Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']]):
        pulumi.set(self, "ca_certificate_key_quality_check", value)

    @property
    @pulumi.getter(name="conflictingClientIdsCheck")
    def conflicting_client_ids_check(self) -> Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']]:
        return pulumi.get(self, "conflicting_client_ids_check")

    @conflicting_client_ids_check.setter
    def conflicting_client_ids_check(self, value: Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']]):
        pulumi.set(self, "conflicting_client_ids_check", value)

    @property
    @pulumi.getter(name="deviceCertificateExpiringCheck")
    def device_certificate_expiring_check(self) -> Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']]:
        return pulumi.get(self, "device_certificate_expiring_check")

    @device_certificate_expiring_check.setter
    def device_certificate_expiring_check(self, value: Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']]):
        pulumi.set(self, "device_certificate_expiring_check", value)

    @property
    @pulumi.getter(name="deviceCertificateKeyQualityCheck")
    def device_certificate_key_quality_check(self) -> Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']]:
        return pulumi.get(self, "device_certificate_key_quality_check")

    @device_certificate_key_quality_check.setter
    def device_certificate_key_quality_check(self, value: Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']]):
        pulumi.set(self, "device_certificate_key_quality_check", value)

    @property
    @pulumi.getter(name="deviceCertificateSharedCheck")
    def device_certificate_shared_check(self) -> Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']]:
        return pulumi.get(self, "device_certificate_shared_check")

    @device_certificate_shared_check.setter
    def device_certificate_shared_check(self, value: Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']]):
        pulumi.set(self, "device_certificate_shared_check", value)

    @property
    @pulumi.getter(name="iotPolicyOverlyPermissiveCheck")
    def iot_policy_overly_permissive_check(self) -> Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']]:
        return pulumi.get(self, "iot_policy_overly_permissive_check")

    @iot_policy_overly_permissive_check.setter
    def iot_policy_overly_permissive_check(self, value: Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']]):
        pulumi.set(self, "iot_policy_overly_permissive_check", value)

    @property
    @pulumi.getter(name="iotRoleAliasAllowsAccessToUnusedServicesCheck")
    def iot_role_alias_allows_access_to_unused_services_check(self) -> Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']]:
        return pulumi.get(self, "iot_role_alias_allows_access_to_unused_services_check")

    @iot_role_alias_allows_access_to_unused_services_check.setter
    def iot_role_alias_allows_access_to_unused_services_check(self, value: Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']]):
        pulumi.set(self, "iot_role_alias_allows_access_to_unused_services_check", value)

    @property
    @pulumi.getter(name="iotRoleAliasOverlyPermissiveCheck")
    def iot_role_alias_overly_permissive_check(self) -> Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']]:
        return pulumi.get(self, "iot_role_alias_overly_permissive_check")

    @iot_role_alias_overly_permissive_check.setter
    def iot_role_alias_overly_permissive_check(self, value: Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']]):
        pulumi.set(self, "iot_role_alias_overly_permissive_check", value)

    @property
    @pulumi.getter(name="loggingDisabledCheck")
    def logging_disabled_check(self) -> Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']]:
        return pulumi.get(self, "logging_disabled_check")

    @logging_disabled_check.setter
    def logging_disabled_check(self, value: Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']]):
        pulumi.set(self, "logging_disabled_check", value)

    @property
    @pulumi.getter(name="revokedCaCertificateStillActiveCheck")
    def revoked_ca_certificate_still_active_check(self) -> Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']]:
        return pulumi.get(self, "revoked_ca_certificate_still_active_check")

    @revoked_ca_certificate_still_active_check.setter
    def revoked_ca_certificate_still_active_check(self, value: Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']]):
        pulumi.set(self, "revoked_ca_certificate_still_active_check", value)

    @property
    @pulumi.getter(name="revokedDeviceCertificateStillActiveCheck")
    def revoked_device_certificate_still_active_check(self) -> Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']]:
        return pulumi.get(self, "revoked_device_certificate_still_active_check")

    @revoked_device_certificate_still_active_check.setter
    def revoked_device_certificate_still_active_check(self, value: Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']]):
        pulumi.set(self, "revoked_device_certificate_still_active_check", value)

    @property
    @pulumi.getter(name="unauthenticatedCognitoRoleOverlyPermissiveCheck")
    def unauthenticated_cognito_role_overly_permissive_check(self) -> Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']]:
        return pulumi.get(self, "unauthenticated_cognito_role_overly_permissive_check")

    @unauthenticated_cognito_role_overly_permissive_check.setter
    def unauthenticated_cognito_role_overly_permissive_check(self, value: Optional[pulumi.Input['AccountAuditConfigurationAuditCheckConfigurationArgs']]):
        pulumi.set(self, "unauthenticated_cognito_role_overly_permissive_check", value)


@pulumi.input_type
class AccountAuditConfigurationAuditCheckConfigurationArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None):
        """
        The configuration for a specific audit check.
        :param pulumi.Input[bool] enabled: True if the check is enabled.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        True if the check is enabled.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)


@pulumi.input_type
class AccountAuditConfigurationAuditNotificationTargetConfigurationsArgs:
    def __init__(__self__, *,
                 sns: Optional[pulumi.Input['AccountAuditConfigurationAuditNotificationTargetArgs']] = None):
        """
        Information about the targets to which audit notifications are sent.
        """
        if sns is not None:
            pulumi.set(__self__, "sns", sns)

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

    @sns.setter
    def sns(self, value: Optional[pulumi.Input['AccountAuditConfigurationAuditNotificationTargetArgs']]):
        pulumi.set(self, "sns", value)


@pulumi.input_type
class AccountAuditConfigurationAuditNotificationTargetArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 role_arn: Optional[pulumi.Input[str]] = None,
                 target_arn: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[bool] enabled: True if notifications to the target are enabled.
        :param pulumi.Input[str] role_arn: The ARN of the role that grants permission to send notifications to the target.
        :param pulumi.Input[str] target_arn: The ARN of the target (SNS topic) to which audit notifications are sent.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if role_arn is not None:
            pulumi.set(__self__, "role_arn", role_arn)
        if target_arn is not None:
            pulumi.set(__self__, "target_arn", target_arn)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        True if notifications to the target are enabled.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> Optional[pulumi.Input[str]]:
        """
        The ARN of the role that grants permission to send notifications to the target.
        """
        return pulumi.get(self, "role_arn")

    @role_arn.setter
    def role_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "role_arn", value)

    @property
    @pulumi.getter(name="targetArn")
    def target_arn(self) -> Optional[pulumi.Input[str]]:
        """
        The ARN of the target (SNS topic) to which audit notifications are sent.
        """
        return pulumi.get(self, "target_arn")

    @target_arn.setter
    def target_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "target_arn", value)


@pulumi.input_type
class AuthorizerTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class CustomMetricTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        A key-value pair to associate with a resource.
        :param pulumi.Input[str] key: The tag's key.
        :param pulumi.Input[str] value: The tag's value.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        The tag's key.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        The tag's value.
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class DimensionTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        A key-value pair to associate with a resource.
        :param pulumi.Input[str] key: The tag's key.
        :param pulumi.Input[str] value: The tag's value.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        The tag's key.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        The tag's value.
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class DomainConfigurationAuthorizerConfigArgs:
    def __init__(__self__, *,
                 allow_authorizer_override: Optional[pulumi.Input[bool]] = None,
                 default_authorizer_name: Optional[pulumi.Input[str]] = None):
        if allow_authorizer_override is not None:
            pulumi.set(__self__, "allow_authorizer_override", allow_authorizer_override)
        if default_authorizer_name is not None:
            pulumi.set(__self__, "default_authorizer_name", default_authorizer_name)

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

    @allow_authorizer_override.setter
    def allow_authorizer_override(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "allow_authorizer_override", value)

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

    @default_authorizer_name.setter
    def default_authorizer_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "default_authorizer_name", value)


@pulumi.input_type
class DomainConfigurationTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class FleetMetricAggregationTypeArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 values: pulumi.Input[Sequence[pulumi.Input[str]]]):
        """
        Aggregation types supported by Fleet Indexing
        :param pulumi.Input[str] name: Fleet Indexing aggregation type names such as Statistics, Percentiles and Cardinality
        :param pulumi.Input[Sequence[pulumi.Input[str]]] values: Fleet Indexing aggregation type values
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        Fleet Indexing aggregation type names such as Statistics, Percentiles and Cardinality
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def values(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        Fleet Indexing aggregation type values
        """
        return pulumi.get(self, "values")

    @values.setter
    def values(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "values", value)


@pulumi.input_type
class FleetMetricTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        A key-value pair to associate with a resource
        :param pulumi.Input[str] key: The tag's key
        :param pulumi.Input[str] value: The tag's value
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        The tag's key
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        The tag's value
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class MitigationActionActionParamsArgs:
    def __init__(__self__, *,
                 add_things_to_thing_group_params: Optional[pulumi.Input['MitigationActionAddThingsToThingGroupParamsArgs']] = None,
                 enable_io_t_logging_params: Optional[pulumi.Input['MitigationActionEnableIoTLoggingParamsArgs']] = None,
                 publish_finding_to_sns_params: Optional[pulumi.Input['MitigationActionPublishFindingToSnsParamsArgs']] = None,
                 replace_default_policy_version_params: Optional[pulumi.Input['MitigationActionReplaceDefaultPolicyVersionParamsArgs']] = None,
                 update_ca_certificate_params: Optional[pulumi.Input['MitigationActionUpdateCACertificateParamsArgs']] = None,
                 update_device_certificate_params: Optional[pulumi.Input['MitigationActionUpdateDeviceCertificateParamsArgs']] = None):
        """
        The set of parameters for this mitigation action. You can specify only one type of parameter (in other words, you can apply only one action for each defined mitigation action).
        """
        if add_things_to_thing_group_params is not None:
            pulumi.set(__self__, "add_things_to_thing_group_params", add_things_to_thing_group_params)
        if enable_io_t_logging_params is not None:
            pulumi.set(__self__, "enable_io_t_logging_params", enable_io_t_logging_params)
        if publish_finding_to_sns_params is not None:
            pulumi.set(__self__, "publish_finding_to_sns_params", publish_finding_to_sns_params)
        if replace_default_policy_version_params is not None:
            pulumi.set(__self__, "replace_default_policy_version_params", replace_default_policy_version_params)
        if update_ca_certificate_params is not None:
            pulumi.set(__self__, "update_ca_certificate_params", update_ca_certificate_params)
        if update_device_certificate_params is not None:
            pulumi.set(__self__, "update_device_certificate_params", update_device_certificate_params)

    @property
    @pulumi.getter(name="addThingsToThingGroupParams")
    def add_things_to_thing_group_params(self) -> Optional[pulumi.Input['MitigationActionAddThingsToThingGroupParamsArgs']]:
        return pulumi.get(self, "add_things_to_thing_group_params")

    @add_things_to_thing_group_params.setter
    def add_things_to_thing_group_params(self, value: Optional[pulumi.Input['MitigationActionAddThingsToThingGroupParamsArgs']]):
        pulumi.set(self, "add_things_to_thing_group_params", value)

    @property
    @pulumi.getter(name="enableIoTLoggingParams")
    def enable_io_t_logging_params(self) -> Optional[pulumi.Input['MitigationActionEnableIoTLoggingParamsArgs']]:
        return pulumi.get(self, "enable_io_t_logging_params")

    @enable_io_t_logging_params.setter
    def enable_io_t_logging_params(self, value: Optional[pulumi.Input['MitigationActionEnableIoTLoggingParamsArgs']]):
        pulumi.set(self, "enable_io_t_logging_params", value)

    @property
    @pulumi.getter(name="publishFindingToSnsParams")
    def publish_finding_to_sns_params(self) -> Optional[pulumi.Input['MitigationActionPublishFindingToSnsParamsArgs']]:
        return pulumi.get(self, "publish_finding_to_sns_params")

    @publish_finding_to_sns_params.setter
    def publish_finding_to_sns_params(self, value: Optional[pulumi.Input['MitigationActionPublishFindingToSnsParamsArgs']]):
        pulumi.set(self, "publish_finding_to_sns_params", value)

    @property
    @pulumi.getter(name="replaceDefaultPolicyVersionParams")
    def replace_default_policy_version_params(self) -> Optional[pulumi.Input['MitigationActionReplaceDefaultPolicyVersionParamsArgs']]:
        return pulumi.get(self, "replace_default_policy_version_params")

    @replace_default_policy_version_params.setter
    def replace_default_policy_version_params(self, value: Optional[pulumi.Input['MitigationActionReplaceDefaultPolicyVersionParamsArgs']]):
        pulumi.set(self, "replace_default_policy_version_params", value)

    @property
    @pulumi.getter(name="updateCACertificateParams")
    def update_ca_certificate_params(self) -> Optional[pulumi.Input['MitigationActionUpdateCACertificateParamsArgs']]:
        return pulumi.get(self, "update_ca_certificate_params")

    @update_ca_certificate_params.setter
    def update_ca_certificate_params(self, value: Optional[pulumi.Input['MitigationActionUpdateCACertificateParamsArgs']]):
        pulumi.set(self, "update_ca_certificate_params", value)

    @property
    @pulumi.getter(name="updateDeviceCertificateParams")
    def update_device_certificate_params(self) -> Optional[pulumi.Input['MitigationActionUpdateDeviceCertificateParamsArgs']]:
        return pulumi.get(self, "update_device_certificate_params")

    @update_device_certificate_params.setter
    def update_device_certificate_params(self, value: Optional[pulumi.Input['MitigationActionUpdateDeviceCertificateParamsArgs']]):
        pulumi.set(self, "update_device_certificate_params", value)


@pulumi.input_type
class MitigationActionAddThingsToThingGroupParamsArgs:
    def __init__(__self__, *,
                 thing_group_names: pulumi.Input[Sequence[pulumi.Input[str]]],
                 override_dynamic_groups: Optional[pulumi.Input[bool]] = None):
        """
        Parameters to define a mitigation action that moves devices associated with a certificate to one or more specified thing groups, typically for quarantine.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] thing_group_names: The list of groups to which you want to add the things that triggered the mitigation action.
        :param pulumi.Input[bool] override_dynamic_groups: Specifies if this mitigation action can move the things that triggered the mitigation action out of one or more dynamic thing groups.
        """
        pulumi.set(__self__, "thing_group_names", thing_group_names)
        if override_dynamic_groups is not None:
            pulumi.set(__self__, "override_dynamic_groups", override_dynamic_groups)

    @property
    @pulumi.getter(name="thingGroupNames")
    def thing_group_names(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
        """
        The list of groups to which you want to add the things that triggered the mitigation action.
        """
        return pulumi.get(self, "thing_group_names")

    @thing_group_names.setter
    def thing_group_names(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(self, "thing_group_names", value)

    @property
    @pulumi.getter(name="overrideDynamicGroups")
    def override_dynamic_groups(self) -> Optional[pulumi.Input[bool]]:
        """
        Specifies if this mitigation action can move the things that triggered the mitigation action out of one or more dynamic thing groups.
        """
        return pulumi.get(self, "override_dynamic_groups")

    @override_dynamic_groups.setter
    def override_dynamic_groups(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "override_dynamic_groups", value)


@pulumi.input_type
class MitigationActionEnableIoTLoggingParamsArgs:
    def __init__(__self__, *,
                 log_level: pulumi.Input['MitigationActionEnableIoTLoggingParamsLogLevel'],
                 role_arn_for_logging: pulumi.Input[str]):
        """
        Parameters to define a mitigation action that enables AWS IoT logging at a specified level of detail.
        :param pulumi.Input['MitigationActionEnableIoTLoggingParamsLogLevel'] log_level:  Specifies which types of information are logged.
        :param pulumi.Input[str] role_arn_for_logging:  The ARN of the IAM role used for logging.
        """
        pulumi.set(__self__, "log_level", log_level)
        pulumi.set(__self__, "role_arn_for_logging", role_arn_for_logging)

    @property
    @pulumi.getter(name="logLevel")
    def log_level(self) -> pulumi.Input['MitigationActionEnableIoTLoggingParamsLogLevel']:
        """
         Specifies which types of information are logged.
        """
        return pulumi.get(self, "log_level")

    @log_level.setter
    def log_level(self, value: pulumi.Input['MitigationActionEnableIoTLoggingParamsLogLevel']):
        pulumi.set(self, "log_level", value)

    @property
    @pulumi.getter(name="roleArnForLogging")
    def role_arn_for_logging(self) -> pulumi.Input[str]:
        """
         The ARN of the IAM role used for logging.
        """
        return pulumi.get(self, "role_arn_for_logging")

    @role_arn_for_logging.setter
    def role_arn_for_logging(self, value: pulumi.Input[str]):
        pulumi.set(self, "role_arn_for_logging", value)


@pulumi.input_type
class MitigationActionPublishFindingToSnsParamsArgs:
    def __init__(__self__, *,
                 topic_arn: pulumi.Input[str]):
        """
        Parameters, to define a mitigation action that publishes findings to Amazon SNS. You can implement your own custom actions in response to the Amazon SNS messages.
        :param pulumi.Input[str] topic_arn: The ARN of the topic to which you want to publish the findings.
        """
        pulumi.set(__self__, "topic_arn", topic_arn)

    @property
    @pulumi.getter(name="topicArn")
    def topic_arn(self) -> pulumi.Input[str]:
        """
        The ARN of the topic to which you want to publish the findings.
        """
        return pulumi.get(self, "topic_arn")

    @topic_arn.setter
    def topic_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "topic_arn", value)


@pulumi.input_type
class MitigationActionReplaceDefaultPolicyVersionParamsArgs:
    def __init__(__self__, *,
                 template_name: pulumi.Input['MitigationActionReplaceDefaultPolicyVersionParamsTemplateName']):
        """
        Parameters to define a mitigation action that adds a blank policy to restrict permissions.
        """
        pulumi.set(__self__, "template_name", template_name)

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

    @template_name.setter
    def template_name(self, value: pulumi.Input['MitigationActionReplaceDefaultPolicyVersionParamsTemplateName']):
        pulumi.set(self, "template_name", value)


@pulumi.input_type
class MitigationActionTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        A key-value pair to associate with a resource.
        :param pulumi.Input[str] key: The tag's key.
        :param pulumi.Input[str] value: The tag's value.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        The tag's key.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        The tag's value.
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class MitigationActionUpdateCACertificateParamsArgs:
    def __init__(__self__, *,
                 action: pulumi.Input['MitigationActionUpdateCACertificateParamsAction']):
        """
        Parameters to define a mitigation action that changes the state of the CA certificate to inactive.
        """
        pulumi.set(__self__, "action", action)

    @property
    @pulumi.getter
    def action(self) -> pulumi.Input['MitigationActionUpdateCACertificateParamsAction']:
        return pulumi.get(self, "action")

    @action.setter
    def action(self, value: pulumi.Input['MitigationActionUpdateCACertificateParamsAction']):
        pulumi.set(self, "action", value)


@pulumi.input_type
class MitigationActionUpdateDeviceCertificateParamsArgs:
    def __init__(__self__, *,
                 action: pulumi.Input['MitigationActionUpdateDeviceCertificateParamsAction']):
        """
        Parameters to define a mitigation action that changes the state of the device certificate to inactive.
        """
        pulumi.set(__self__, "action", action)

    @property
    @pulumi.getter
    def action(self) -> pulumi.Input['MitigationActionUpdateDeviceCertificateParamsAction']:
        return pulumi.get(self, "action")

    @action.setter
    def action(self, value: pulumi.Input['MitigationActionUpdateDeviceCertificateParamsAction']):
        pulumi.set(self, "action", value)


@pulumi.input_type
class ProvisioningTemplateProvisioningHookArgs:
    def __init__(__self__, *,
                 payload_version: Optional[pulumi.Input[str]] = None,
                 target_arn: Optional[pulumi.Input[str]] = None):
        if payload_version is not None:
            pulumi.set(__self__, "payload_version", payload_version)
        if target_arn is not None:
            pulumi.set(__self__, "target_arn", target_arn)

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

    @payload_version.setter
    def payload_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "payload_version", value)

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

    @target_arn.setter
    def target_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "target_arn", value)


@pulumi.input_type
class ProvisioningTemplateTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class ScheduledAuditTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        A key-value pair to associate with a resource.
        :param pulumi.Input[str] key: The tag's key.
        :param pulumi.Input[str] value: The tag's value.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        The tag's key.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        The tag's value.
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class SecurityProfileBehaviorCriteriaArgs:
    def __init__(__self__, *,
                 comparison_operator: Optional[pulumi.Input['SecurityProfileBehaviorCriteriaComparisonOperator']] = None,
                 consecutive_datapoints_to_alarm: Optional[pulumi.Input[int]] = None,
                 consecutive_datapoints_to_clear: Optional[pulumi.Input[int]] = None,
                 duration_seconds: Optional[pulumi.Input[int]] = None,
                 ml_detection_config: Optional[pulumi.Input['SecurityProfileMachineLearningDetectionConfigArgs']] = None,
                 statistical_threshold: Optional[pulumi.Input['SecurityProfileStatisticalThresholdArgs']] = None,
                 value: Optional[pulumi.Input['SecurityProfileMetricValueArgs']] = None):
        """
        The criteria by which the behavior is determined to be normal.
        :param pulumi.Input['SecurityProfileBehaviorCriteriaComparisonOperator'] comparison_operator: The operator that relates the thing measured (metric) to the criteria (containing a value or statisticalThreshold).
        :param pulumi.Input[int] consecutive_datapoints_to_alarm: If a device is in violation of the behavior for the specified number of consecutive datapoints, an alarm occurs. If not specified, the default is 1.
        :param pulumi.Input[int] consecutive_datapoints_to_clear: If an alarm has occurred and the offending device is no longer in violation of the behavior for the specified number of consecutive datapoints, the alarm is cleared. If not specified, the default is 1.
        :param pulumi.Input[int] duration_seconds: Use this to specify the time duration over which the behavior is evaluated.
        """
        if comparison_operator is not None:
            pulumi.set(__self__, "comparison_operator", comparison_operator)
        if consecutive_datapoints_to_alarm is not None:
            pulumi.set(__self__, "consecutive_datapoints_to_alarm", consecutive_datapoints_to_alarm)
        if consecutive_datapoints_to_clear is not None:
            pulumi.set(__self__, "consecutive_datapoints_to_clear", consecutive_datapoints_to_clear)
        if duration_seconds is not None:
            pulumi.set(__self__, "duration_seconds", duration_seconds)
        if ml_detection_config is not None:
            pulumi.set(__self__, "ml_detection_config", ml_detection_config)
        if statistical_threshold is not None:
            pulumi.set(__self__, "statistical_threshold", statistical_threshold)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter(name="comparisonOperator")
    def comparison_operator(self) -> Optional[pulumi.Input['SecurityProfileBehaviorCriteriaComparisonOperator']]:
        """
        The operator that relates the thing measured (metric) to the criteria (containing a value or statisticalThreshold).
        """
        return pulumi.get(self, "comparison_operator")

    @comparison_operator.setter
    def comparison_operator(self, value: Optional[pulumi.Input['SecurityProfileBehaviorCriteriaComparisonOperator']]):
        pulumi.set(self, "comparison_operator", value)

    @property
    @pulumi.getter(name="consecutiveDatapointsToAlarm")
    def consecutive_datapoints_to_alarm(self) -> Optional[pulumi.Input[int]]:
        """
        If a device is in violation of the behavior for the specified number of consecutive datapoints, an alarm occurs. If not specified, the default is 1.
        """
        return pulumi.get(self, "consecutive_datapoints_to_alarm")

    @consecutive_datapoints_to_alarm.setter
    def consecutive_datapoints_to_alarm(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "consecutive_datapoints_to_alarm", value)

    @property
    @pulumi.getter(name="consecutiveDatapointsToClear")
    def consecutive_datapoints_to_clear(self) -> Optional[pulumi.Input[int]]:
        """
        If an alarm has occurred and the offending device is no longer in violation of the behavior for the specified number of consecutive datapoints, the alarm is cleared. If not specified, the default is 1.
        """
        return pulumi.get(self, "consecutive_datapoints_to_clear")

    @consecutive_datapoints_to_clear.setter
    def consecutive_datapoints_to_clear(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "consecutive_datapoints_to_clear", value)

    @property
    @pulumi.getter(name="durationSeconds")
    def duration_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        Use this to specify the time duration over which the behavior is evaluated.
        """
        return pulumi.get(self, "duration_seconds")

    @duration_seconds.setter
    def duration_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "duration_seconds", value)

    @property
    @pulumi.getter(name="mlDetectionConfig")
    def ml_detection_config(self) -> Optional[pulumi.Input['SecurityProfileMachineLearningDetectionConfigArgs']]:
        return pulumi.get(self, "ml_detection_config")

    @ml_detection_config.setter
    def ml_detection_config(self, value: Optional[pulumi.Input['SecurityProfileMachineLearningDetectionConfigArgs']]):
        pulumi.set(self, "ml_detection_config", value)

    @property
    @pulumi.getter(name="statisticalThreshold")
    def statistical_threshold(self) -> Optional[pulumi.Input['SecurityProfileStatisticalThresholdArgs']]:
        return pulumi.get(self, "statistical_threshold")

    @statistical_threshold.setter
    def statistical_threshold(self, value: Optional[pulumi.Input['SecurityProfileStatisticalThresholdArgs']]):
        pulumi.set(self, "statistical_threshold", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input['SecurityProfileMetricValueArgs']]:
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input['SecurityProfileMetricValueArgs']]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class SecurityProfileBehaviorArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 criteria: Optional[pulumi.Input['SecurityProfileBehaviorCriteriaArgs']] = None,
                 metric: Optional[pulumi.Input[str]] = None,
                 metric_dimension: Optional[pulumi.Input['SecurityProfileMetricDimensionArgs']] = None,
                 suppress_alerts: Optional[pulumi.Input[bool]] = None):
        """
        A security profile behavior.
        :param pulumi.Input[str] name: The name for the behavior.
        :param pulumi.Input[str] metric: What is measured by the behavior.
        :param pulumi.Input[bool] suppress_alerts: Manage Detect alarm SNS notifications by setting behavior notification to on or suppressed. Detect will continue to performing device behavior evaluations. However, suppressed alarms wouldn't be forwarded for SNS notification.
        """
        pulumi.set(__self__, "name", name)
        if criteria is not None:
            pulumi.set(__self__, "criteria", criteria)
        if metric is not None:
            pulumi.set(__self__, "metric", metric)
        if metric_dimension is not None:
            pulumi.set(__self__, "metric_dimension", metric_dimension)
        if suppress_alerts is not None:
            pulumi.set(__self__, "suppress_alerts", suppress_alerts)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        The name for the behavior.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def criteria(self) -> Optional[pulumi.Input['SecurityProfileBehaviorCriteriaArgs']]:
        return pulumi.get(self, "criteria")

    @criteria.setter
    def criteria(self, value: Optional[pulumi.Input['SecurityProfileBehaviorCriteriaArgs']]):
        pulumi.set(self, "criteria", value)

    @property
    @pulumi.getter
    def metric(self) -> Optional[pulumi.Input[str]]:
        """
        What is measured by the behavior.
        """
        return pulumi.get(self, "metric")

    @metric.setter
    def metric(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "metric", value)

    @property
    @pulumi.getter(name="metricDimension")
    def metric_dimension(self) -> Optional[pulumi.Input['SecurityProfileMetricDimensionArgs']]:
        return pulumi.get(self, "metric_dimension")

    @metric_dimension.setter
    def metric_dimension(self, value: Optional[pulumi.Input['SecurityProfileMetricDimensionArgs']]):
        pulumi.set(self, "metric_dimension", value)

    @property
    @pulumi.getter(name="suppressAlerts")
    def suppress_alerts(self) -> Optional[pulumi.Input[bool]]:
        """
        Manage Detect alarm SNS notifications by setting behavior notification to on or suppressed. Detect will continue to performing device behavior evaluations. However, suppressed alarms wouldn't be forwarded for SNS notification.
        """
        return pulumi.get(self, "suppress_alerts")

    @suppress_alerts.setter
    def suppress_alerts(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "suppress_alerts", value)


@pulumi.input_type
class SecurityProfileMachineLearningDetectionConfigArgs:
    def __init__(__self__, *,
                 confidence_level: Optional[pulumi.Input['SecurityProfileMachineLearningDetectionConfigConfidenceLevel']] = None):
        """
        The configuration of an ML Detect Security Profile.
        :param pulumi.Input['SecurityProfileMachineLearningDetectionConfigConfidenceLevel'] confidence_level: The sensitivity of anomalous behavior evaluation. Can be Low, Medium, or High.
        """
        if confidence_level is not None:
            pulumi.set(__self__, "confidence_level", confidence_level)

    @property
    @pulumi.getter(name="confidenceLevel")
    def confidence_level(self) -> Optional[pulumi.Input['SecurityProfileMachineLearningDetectionConfigConfidenceLevel']]:
        """
        The sensitivity of anomalous behavior evaluation. Can be Low, Medium, or High.
        """
        return pulumi.get(self, "confidence_level")

    @confidence_level.setter
    def confidence_level(self, value: Optional[pulumi.Input['SecurityProfileMachineLearningDetectionConfigConfidenceLevel']]):
        pulumi.set(self, "confidence_level", value)


@pulumi.input_type
class SecurityProfileMetricDimensionArgs:
    def __init__(__self__, *,
                 dimension_name: pulumi.Input[str],
                 operator: Optional[pulumi.Input['SecurityProfileMetricDimensionOperator']] = None):
        """
        The dimension of a metric.
        :param pulumi.Input[str] dimension_name: A unique identifier for the dimension.
        :param pulumi.Input['SecurityProfileMetricDimensionOperator'] operator: Defines how the dimensionValues of a dimension are interpreted.
        """
        pulumi.set(__self__, "dimension_name", dimension_name)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)

    @property
    @pulumi.getter(name="dimensionName")
    def dimension_name(self) -> pulumi.Input[str]:
        """
        A unique identifier for the dimension.
        """
        return pulumi.get(self, "dimension_name")

    @dimension_name.setter
    def dimension_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "dimension_name", value)

    @property
    @pulumi.getter
    def operator(self) -> Optional[pulumi.Input['SecurityProfileMetricDimensionOperator']]:
        """
        Defines how the dimensionValues of a dimension are interpreted.
        """
        return pulumi.get(self, "operator")

    @operator.setter
    def operator(self, value: Optional[pulumi.Input['SecurityProfileMetricDimensionOperator']]):
        pulumi.set(self, "operator", value)


@pulumi.input_type
class SecurityProfileMetricToRetainArgs:
    def __init__(__self__, *,
                 metric: pulumi.Input[str],
                 metric_dimension: Optional[pulumi.Input['SecurityProfileMetricDimensionArgs']] = None):
        """
        The metric you want to retain. Dimensions are optional.
        :param pulumi.Input[str] metric: What is measured by the behavior.
        """
        pulumi.set(__self__, "metric", metric)
        if metric_dimension is not None:
            pulumi.set(__self__, "metric_dimension", metric_dimension)

    @property
    @pulumi.getter
    def metric(self) -> pulumi.Input[str]:
        """
        What is measured by the behavior.
        """
        return pulumi.get(self, "metric")

    @metric.setter
    def metric(self, value: pulumi.Input[str]):
        pulumi.set(self, "metric", value)

    @property
    @pulumi.getter(name="metricDimension")
    def metric_dimension(self) -> Optional[pulumi.Input['SecurityProfileMetricDimensionArgs']]:
        return pulumi.get(self, "metric_dimension")

    @metric_dimension.setter
    def metric_dimension(self, value: Optional[pulumi.Input['SecurityProfileMetricDimensionArgs']]):
        pulumi.set(self, "metric_dimension", value)


@pulumi.input_type
class SecurityProfileMetricValueArgs:
    def __init__(__self__, *,
                 cidrs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 count: Optional[pulumi.Input[str]] = None,
                 number: Optional[pulumi.Input[float]] = None,
                 numbers: Optional[pulumi.Input[Sequence[pulumi.Input[float]]]] = None,
                 ports: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None,
                 strings: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        The value to be compared with the metric.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] cidrs: If the ComparisonOperator calls for a set of CIDRs, use this to specify that set to be compared with the metric.
        :param pulumi.Input[str] count: If the ComparisonOperator calls for a numeric value, use this to specify that (integer) numeric value to be compared with the metric.
        :param pulumi.Input[float] number: The numeral value of a metric.
        :param pulumi.Input[Sequence[pulumi.Input[float]]] numbers: The numeral values of a metric.
        :param pulumi.Input[Sequence[pulumi.Input[int]]] ports: If the ComparisonOperator calls for a set of ports, use this to specify that set to be compared with the metric.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] strings: The string values of a metric.
        """
        if cidrs is not None:
            pulumi.set(__self__, "cidrs", cidrs)
        if count is not None:
            pulumi.set(__self__, "count", count)
        if number is not None:
            pulumi.set(__self__, "number", number)
        if numbers is not None:
            pulumi.set(__self__, "numbers", numbers)
        if ports is not None:
            pulumi.set(__self__, "ports", ports)
        if strings is not None:
            pulumi.set(__self__, "strings", strings)

    @property
    @pulumi.getter
    def cidrs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        If the ComparisonOperator calls for a set of CIDRs, use this to specify that set to be compared with the metric.
        """
        return pulumi.get(self, "cidrs")

    @cidrs.setter
    def cidrs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "cidrs", value)

    @property
    @pulumi.getter
    def count(self) -> Optional[pulumi.Input[str]]:
        """
        If the ComparisonOperator calls for a numeric value, use this to specify that (integer) numeric value to be compared with the metric.
        """
        return pulumi.get(self, "count")

    @count.setter
    def count(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "count", value)

    @property
    @pulumi.getter
    def number(self) -> Optional[pulumi.Input[float]]:
        """
        The numeral value of a metric.
        """
        return pulumi.get(self, "number")

    @number.setter
    def number(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "number", value)

    @property
    @pulumi.getter
    def numbers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[float]]]]:
        """
        The numeral values of a metric.
        """
        return pulumi.get(self, "numbers")

    @numbers.setter
    def numbers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[float]]]]):
        pulumi.set(self, "numbers", value)

    @property
    @pulumi.getter
    def ports(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]:
        """
        If the ComparisonOperator calls for a set of ports, use this to specify that set to be compared with the metric.
        """
        return pulumi.get(self, "ports")

    @ports.setter
    def ports(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]):
        pulumi.set(self, "ports", value)

    @property
    @pulumi.getter
    def strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The string values of a metric.
        """
        return pulumi.get(self, "strings")

    @strings.setter
    def strings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "strings", value)


@pulumi.input_type
class SecurityProfileStatisticalThresholdArgs:
    def __init__(__self__, *,
                 statistic: Optional[pulumi.Input['SecurityProfileStatisticalThresholdStatistic']] = None):
        """
        A statistical ranking (percentile) which indicates a threshold value by which a behavior is determined to be in compliance or in violation of the behavior.
        :param pulumi.Input['SecurityProfileStatisticalThresholdStatistic'] statistic: The percentile which resolves to a threshold value by which compliance with a behavior is determined
        """
        if statistic is not None:
            pulumi.set(__self__, "statistic", statistic)

    @property
    @pulumi.getter
    def statistic(self) -> Optional[pulumi.Input['SecurityProfileStatisticalThresholdStatistic']]:
        """
        The percentile which resolves to a threshold value by which compliance with a behavior is determined
        """
        return pulumi.get(self, "statistic")

    @statistic.setter
    def statistic(self, value: Optional[pulumi.Input['SecurityProfileStatisticalThresholdStatistic']]):
        pulumi.set(self, "statistic", value)


@pulumi.input_type
class SecurityProfileTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        A key-value pair to associate with a resource.
        :param pulumi.Input[str] key: The tag's key.
        :param pulumi.Input[str] value: The tag's value.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        The tag's key.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input[str]:
        """
        The tag's value.
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class ThingAttributePayloadArgs:
    def __init__(__self__, *,
                 attributes: Optional[Any] = None):
        if attributes is not None:
            pulumi.set(__self__, "attributes", attributes)

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

    @attributes.setter
    def attributes(self, value: Optional[Any]):
        pulumi.set(self, "attributes", value)


@pulumi.input_type
class TopicRuleActionArgs:
    def __init__(__self__, *,
                 cloudwatch_alarm: Optional[pulumi.Input['TopicRuleCloudwatchAlarmActionArgs']] = None,
                 cloudwatch_logs: Optional[pulumi.Input['TopicRuleCloudwatchLogsActionArgs']] = None,
                 cloudwatch_metric: Optional[pulumi.Input['TopicRuleCloudwatchMetricActionArgs']] = None,
                 dynamo_db: Optional[pulumi.Input['TopicRuleDynamoDBActionArgs']] = None,
                 dynamo_d_bv2: Optional[pulumi.Input['TopicRuleDynamoDBv2ActionArgs']] = None,
                 elasticsearch: Optional[pulumi.Input['TopicRuleElasticsearchActionArgs']] = None,
                 firehose: Optional[pulumi.Input['TopicRuleFirehoseActionArgs']] = None,
                 http: Optional[pulumi.Input['TopicRuleHttpActionArgs']] = None,
                 iot_analytics: Optional[pulumi.Input['TopicRuleIotAnalyticsActionArgs']] = None,
                 iot_events: Optional[pulumi.Input['TopicRuleIotEventsActionArgs']] = None,
                 iot_site_wise: Optional[pulumi.Input['TopicRuleIotSiteWiseActionArgs']] = None,
                 kafka: Optional[pulumi.Input['TopicRuleKafkaActionArgs']] = None,
                 kinesis: Optional[pulumi.Input['TopicRuleKinesisActionArgs']] = None,
                 lambda_: Optional[pulumi.Input['TopicRuleLambdaActionArgs']] = None,
                 open_search: Optional[pulumi.Input['TopicRuleOpenSearchActionArgs']] = None,
                 republish: Optional[pulumi.Input['TopicRuleRepublishActionArgs']] = None,
                 s3: Optional[pulumi.Input['TopicRuleS3ActionArgs']] = None,
                 sns: Optional[pulumi.Input['TopicRuleSnsActionArgs']] = None,
                 sqs: Optional[pulumi.Input['TopicRuleSqsActionArgs']] = None,
                 step_functions: Optional[pulumi.Input['TopicRuleStepFunctionsActionArgs']] = None,
                 timestream: Optional[pulumi.Input['TopicRuleTimestreamActionArgs']] = 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 dynamo_db is not None:
            pulumi.set(__self__, "dynamo_db", dynamo_db)
        if dynamo_d_bv2 is not None:
            pulumi.set(__self__, "dynamo_d_bv2", dynamo_d_bv2)
        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 iot_site_wise is not None:
            pulumi.set(__self__, "iot_site_wise", iot_site_wise)
        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 open_search is not None:
            pulumi.set(__self__, "open_search", open_search)
        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[pulumi.Input['TopicRuleCloudwatchAlarmActionArgs']]:
        return pulumi.get(self, "cloudwatch_alarm")

    @cloudwatch_alarm.setter
    def cloudwatch_alarm(self, value: Optional[pulumi.Input['TopicRuleCloudwatchAlarmActionArgs']]):
        pulumi.set(self, "cloudwatch_alarm", value)

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

    @cloudwatch_logs.setter
    def cloudwatch_logs(self, value: Optional[pulumi.Input['TopicRuleCloudwatchLogsActionArgs']]):
        pulumi.set(self, "cloudwatch_logs", value)

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

    @cloudwatch_metric.setter
    def cloudwatch_metric(self, value: Optional[pulumi.Input['TopicRuleCloudwatchMetricActionArgs']]):
        pulumi.set(self, "cloudwatch_metric", value)

    @property
    @pulumi.getter(name="dynamoDB")
    def dynamo_db(self) -> Optional[pulumi.Input['TopicRuleDynamoDBActionArgs']]:
        return pulumi.get(self, "dynamo_db")

    @dynamo_db.setter
    def dynamo_db(self, value: Optional[pulumi.Input['TopicRuleDynamoDBActionArgs']]):
        pulumi.set(self, "dynamo_db", value)

    @property
    @pulumi.getter(name="dynamoDBv2")
    def dynamo_d_bv2(self) -> Optional[pulumi.Input['TopicRuleDynamoDBv2ActionArgs']]:
        return pulumi.get(self, "dynamo_d_bv2")

    @dynamo_d_bv2.setter
    def dynamo_d_bv2(self, value: Optional[pulumi.Input['TopicRuleDynamoDBv2ActionArgs']]):
        pulumi.set(self, "dynamo_d_bv2", value)

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

    @elasticsearch.setter
    def elasticsearch(self, value: Optional[pulumi.Input['TopicRuleElasticsearchActionArgs']]):
        pulumi.set(self, "elasticsearch", value)

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

    @firehose.setter
    def firehose(self, value: Optional[pulumi.Input['TopicRuleFirehoseActionArgs']]):
        pulumi.set(self, "firehose", value)

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

    @http.setter
    def http(self, value: Optional[pulumi.Input['TopicRuleHttpActionArgs']]):
        pulumi.set(self, "http", value)

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

    @iot_analytics.setter
    def iot_analytics(self, value: Optional[pulumi.Input['TopicRuleIotAnalyticsActionArgs']]):
        pulumi.set(self, "iot_analytics", value)

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

    @iot_events.setter
    def iot_events(self, value: Optional[pulumi.Input['TopicRuleIotEventsActionArgs']]):
        pulumi.set(self, "iot_events", value)

    @property
    @pulumi.getter(name="iotSiteWise")
    def iot_site_wise(self) -> Optional[pulumi.Input['TopicRuleIotSiteWiseActionArgs']]:
        return pulumi.get(self, "iot_site_wise")

    @iot_site_wise.setter
    def iot_site_wise(self, value: Optional[pulumi.Input['TopicRuleIotSiteWiseActionArgs']]):
        pulumi.set(self, "iot_site_wise", value)

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

    @kafka.setter
    def kafka(self, value: Optional[pulumi.Input['TopicRuleKafkaActionArgs']]):
        pulumi.set(self, "kafka", value)

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

    @kinesis.setter
    def kinesis(self, value: Optional[pulumi.Input['TopicRuleKinesisActionArgs']]):
        pulumi.set(self, "kinesis", value)

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

    @lambda_.setter
    def lambda_(self, value: Optional[pulumi.Input['TopicRuleLambdaActionArgs']]):
        pulumi.set(self, "lambda_", value)

    @property
    @pulumi.getter(name="openSearch")
    def open_search(self) -> Optional[pulumi.Input['TopicRuleOpenSearchActionArgs']]:
        return pulumi.get(self, "open_search")

    @open_search.setter
    def open_search(self, value: Optional[pulumi.Input['TopicRuleOpenSearchActionArgs']]):
        pulumi.set(self, "open_search", value)

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

    @republish.setter
    def republish(self, value: Optional[pulumi.Input['TopicRuleRepublishActionArgs']]):
        pulumi.set(self, "republish", value)

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

    @s3.setter
    def s3(self, value: Optional[pulumi.Input['TopicRuleS3ActionArgs']]):
        pulumi.set(self, "s3", value)

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

    @sns.setter
    def sns(self, value: Optional[pulumi.Input['TopicRuleSnsActionArgs']]):
        pulumi.set(self, "sns", value)

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

    @sqs.setter
    def sqs(self, value: Optional[pulumi.Input['TopicRuleSqsActionArgs']]):
        pulumi.set(self, "sqs", value)

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

    @step_functions.setter
    def step_functions(self, value: Optional[pulumi.Input['TopicRuleStepFunctionsActionArgs']]):
        pulumi.set(self, "step_functions", value)

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

    @timestream.setter
    def timestream(self, value: Optional[pulumi.Input['TopicRuleTimestreamActionArgs']]):
        pulumi.set(self, "timestream", value)


@pulumi.input_type
class TopicRuleAssetPropertyTimestampArgs:
    def __init__(__self__, *,
                 time_in_seconds: pulumi.Input[str],
                 offset_in_nanos: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "time_in_seconds", time_in_seconds)
        if offset_in_nanos is not None:
            pulumi.set(__self__, "offset_in_nanos", offset_in_nanos)

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

    @time_in_seconds.setter
    def time_in_seconds(self, value: pulumi.Input[str]):
        pulumi.set(self, "time_in_seconds", value)

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

    @offset_in_nanos.setter
    def offset_in_nanos(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "offset_in_nanos", value)


@pulumi.input_type
class TopicRuleAssetPropertyValueArgs:
    def __init__(__self__, *,
                 timestamp: pulumi.Input['TopicRuleAssetPropertyTimestampArgs'],
                 value: pulumi.Input['TopicRuleAssetPropertyVariantArgs'],
                 quality: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "timestamp", timestamp)
        pulumi.set(__self__, "value", value)
        if quality is not None:
            pulumi.set(__self__, "quality", quality)

    @property
    @pulumi.getter
    def timestamp(self) -> pulumi.Input['TopicRuleAssetPropertyTimestampArgs']:
        return pulumi.get(self, "timestamp")

    @timestamp.setter
    def timestamp(self, value: pulumi.Input['TopicRuleAssetPropertyTimestampArgs']):
        pulumi.set(self, "timestamp", value)

    @property
    @pulumi.getter
    def value(self) -> pulumi.Input['TopicRuleAssetPropertyVariantArgs']:
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input['TopicRuleAssetPropertyVariantArgs']):
        pulumi.set(self, "value", value)

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

    @quality.setter
    def quality(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "quality", value)


@pulumi.input_type
class TopicRuleAssetPropertyVariantArgs:
    def __init__(__self__, *,
                 boolean_value: Optional[pulumi.Input[str]] = None,
                 double_value: Optional[pulumi.Input[str]] = None,
                 integer_value: Optional[pulumi.Input[str]] = None,
                 string_value: Optional[pulumi.Input[str]] = None):
        if boolean_value is not None:
            pulumi.set(__self__, "boolean_value", boolean_value)
        if double_value is not None:
            pulumi.set(__self__, "double_value", double_value)
        if integer_value is not None:
            pulumi.set(__self__, "integer_value", integer_value)
        if string_value is not None:
            pulumi.set(__self__, "string_value", string_value)

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

    @boolean_value.setter
    def boolean_value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "boolean_value", value)

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

    @double_value.setter
    def double_value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "double_value", value)

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

    @integer_value.setter
    def integer_value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "integer_value", value)

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

    @string_value.setter
    def string_value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "string_value", value)


@pulumi.input_type
class TopicRuleCloudwatchAlarmActionArgs:
    def __init__(__self__, *,
                 alarm_name: pulumi.Input[str],
                 role_arn: pulumi.Input[str],
                 state_reason: pulumi.Input[str],
                 state_value: pulumi.Input[str]):
        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) -> pulumi.Input[str]:
        return pulumi.get(self, "alarm_name")

    @alarm_name.setter
    def alarm_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "alarm_name", value)

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

    @role_arn.setter
    def role_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "role_arn", value)

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

    @state_reason.setter
    def state_reason(self, value: pulumi.Input[str]):
        pulumi.set(self, "state_reason", value)

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

    @state_value.setter
    def state_value(self, value: pulumi.Input[str]):
        pulumi.set(self, "state_value", value)


@pulumi.input_type
class TopicRuleCloudwatchLogsActionArgs:
    def __init__(__self__, *,
                 log_group_name: pulumi.Input[str],
                 role_arn: pulumi.Input[str]):
        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) -> pulumi.Input[str]:
        return pulumi.get(self, "log_group_name")

    @log_group_name.setter
    def log_group_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "log_group_name", value)

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

    @role_arn.setter
    def role_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "role_arn", value)


@pulumi.input_type
class TopicRuleCloudwatchMetricActionArgs:
    def __init__(__self__, *,
                 metric_name: pulumi.Input[str],
                 metric_namespace: pulumi.Input[str],
                 metric_unit: pulumi.Input[str],
                 metric_value: pulumi.Input[str],
                 role_arn: pulumi.Input[str],
                 metric_timestamp: Optional[pulumi.Input[str]] = None):
        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) -> pulumi.Input[str]:
        return pulumi.get(self, "metric_name")

    @metric_name.setter
    def metric_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "metric_name", value)

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

    @metric_namespace.setter
    def metric_namespace(self, value: pulumi.Input[str]):
        pulumi.set(self, "metric_namespace", value)

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

    @metric_unit.setter
    def metric_unit(self, value: pulumi.Input[str]):
        pulumi.set(self, "metric_unit", value)

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

    @metric_value.setter
    def metric_value(self, value: pulumi.Input[str]):
        pulumi.set(self, "metric_value", value)

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

    @role_arn.setter
    def role_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "role_arn", value)

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

    @metric_timestamp.setter
    def metric_timestamp(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "metric_timestamp", value)


@pulumi.input_type
class TopicRuleDestinationHttpUrlDestinationSummaryArgs:
    def __init__(__self__, *,
                 confirmation_url: Optional[pulumi.Input[str]] = None):
        if confirmation_url is not None:
            pulumi.set(__self__, "confirmation_url", confirmation_url)

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

    @confirmation_url.setter
    def confirmation_url(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "confirmation_url", value)


@pulumi.input_type
class TopicRuleDestinationVpcDestinationPropertiesArgs:
    def __init__(__self__, *,
                 role_arn: Optional[pulumi.Input[str]] = None,
                 security_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 vpc_id: Optional[pulumi.Input[str]] = None):
        if role_arn is not None:
            pulumi.set(__self__, "role_arn", role_arn)
        if security_groups is not None:
            pulumi.set(__self__, "security_groups", security_groups)
        if subnet_ids is not None:
            pulumi.set(__self__, "subnet_ids", subnet_ids)
        if vpc_id is not None:
            pulumi.set(__self__, "vpc_id", vpc_id)

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

    @role_arn.setter
    def role_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "role_arn", value)

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

    @security_groups.setter
    def security_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "security_groups", value)

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

    @subnet_ids.setter
    def subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "subnet_ids", value)

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

    @vpc_id.setter
    def vpc_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "vpc_id", value)


@pulumi.input_type
class TopicRuleDynamoDBActionArgs:
    def __init__(__self__, *,
                 hash_key_field: pulumi.Input[str],
                 hash_key_value: pulumi.Input[str],
                 role_arn: pulumi.Input[str],
                 table_name: pulumi.Input[str],
                 hash_key_type: Optional[pulumi.Input[str]] = None,
                 payload_field: Optional[pulumi.Input[str]] = None,
                 range_key_field: Optional[pulumi.Input[str]] = None,
                 range_key_type: Optional[pulumi.Input[str]] = None,
                 range_key_value: Optional[pulumi.Input[str]] = None):
        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 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) -> pulumi.Input[str]:
        return pulumi.get(self, "hash_key_field")

    @hash_key_field.setter
    def hash_key_field(self, value: pulumi.Input[str]):
        pulumi.set(self, "hash_key_field", value)

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

    @hash_key_value.setter
    def hash_key_value(self, value: pulumi.Input[str]):
        pulumi.set(self, "hash_key_value", value)

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

    @role_arn.setter
    def role_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "role_arn", value)

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

    @table_name.setter
    def table_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "table_name", value)

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

    @hash_key_type.setter
    def hash_key_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "hash_key_type", value)

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

    @payload_field.setter
    def payload_field(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "payload_field", value)

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

    @range_key_field.setter
    def range_key_field(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "range_key_field", value)

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

    @range_key_type.setter
    def range_key_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "range_key_type", value)

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

    @range_key_value.setter
    def range_key_value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "range_key_value", value)


@pulumi.input_type
class TopicRuleDynamoDBv2ActionArgs:
    def __init__(__self__, *,
                 put_item: Optional[pulumi.Input['TopicRulePutItemInputArgs']] = None,
                 role_arn: Optional[pulumi.Input[str]] = None):
        if put_item is not None:
            pulumi.set(__self__, "put_item", put_item)
        if role_arn is not None:
            pulumi.set(__self__, "role_arn", role_arn)

    @property
    @pulumi.getter(name="putItem")
    def put_item(self) -> Optional[pulumi.Input['TopicRulePutItemInputArgs']]:
        return pulumi.get(self, "put_item")

    @put_item.setter
    def put_item(self, value: Optional[pulumi.Input['TopicRulePutItemInputArgs']]):
        pulumi.set(self, "put_item", value)

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

    @role_arn.setter
    def role_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "role_arn", value)


@pulumi.input_type
class TopicRuleElasticsearchActionArgs:
    def __init__(__self__, *,
                 endpoint: pulumi.Input[str],
                 id: pulumi.Input[str],
                 index: pulumi.Input[str],
                 role_arn: pulumi.Input[str],
                 type: pulumi.Input[str]):
        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) -> pulumi.Input[str]:
        return pulumi.get(self, "endpoint")

    @endpoint.setter
    def endpoint(self, value: pulumi.Input[str]):
        pulumi.set(self, "endpoint", value)

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

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)

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

    @index.setter
    def index(self, value: pulumi.Input[str]):
        pulumi.set(self, "index", value)

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

    @role_arn.setter
    def role_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "role_arn", value)

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

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class TopicRuleFirehoseActionArgs:
    def __init__(__self__, *,
                 delivery_stream_name: pulumi.Input[str],
                 role_arn: pulumi.Input[str],
                 batch_mode: Optional[pulumi.Input[bool]] = None,
                 separator: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "delivery_stream_name", delivery_stream_name)
        pulumi.set(__self__, "role_arn", role_arn)
        if batch_mode is not None:
            pulumi.set(__self__, "batch_mode", batch_mode)
        if separator is not None:
            pulumi.set(__self__, "separator", separator)

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

    @delivery_stream_name.setter
    def delivery_stream_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "delivery_stream_name", value)

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

    @role_arn.setter
    def role_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "role_arn", value)

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

    @batch_mode.setter
    def batch_mode(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "batch_mode", value)

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

    @separator.setter
    def separator(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "separator", value)


@pulumi.input_type
class TopicRuleHttpActionHeaderArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class TopicRuleHttpActionArgs:
    def __init__(__self__, *,
                 url: pulumi.Input[str],
                 auth: Optional[pulumi.Input['TopicRuleHttpAuthorizationArgs']] = None,
                 confirmation_url: Optional[pulumi.Input[str]] = None,
                 headers: Optional[pulumi.Input[Sequence[pulumi.Input['TopicRuleHttpActionHeaderArgs']]]] = None):
        pulumi.set(__self__, "url", url)
        if auth is not None:
            pulumi.set(__self__, "auth", auth)
        if confirmation_url is not None:
            pulumi.set(__self__, "confirmation_url", confirmation_url)
        if headers is not None:
            pulumi.set(__self__, "headers", headers)

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

    @url.setter
    def url(self, value: pulumi.Input[str]):
        pulumi.set(self, "url", value)

    @property
    @pulumi.getter
    def auth(self) -> Optional[pulumi.Input['TopicRuleHttpAuthorizationArgs']]:
        return pulumi.get(self, "auth")

    @auth.setter
    def auth(self, value: Optional[pulumi.Input['TopicRuleHttpAuthorizationArgs']]):
        pulumi.set(self, "auth", value)

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

    @confirmation_url.setter
    def confirmation_url(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "confirmation_url", value)

    @property
    @pulumi.getter
    def headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TopicRuleHttpActionHeaderArgs']]]]:
        return pulumi.get(self, "headers")

    @headers.setter
    def headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TopicRuleHttpActionHeaderArgs']]]]):
        pulumi.set(self, "headers", value)


@pulumi.input_type
class TopicRuleHttpAuthorizationArgs:
    def __init__(__self__, *,
                 sigv4: Optional[pulumi.Input['TopicRuleSigV4AuthorizationArgs']] = None):
        if sigv4 is not None:
            pulumi.set(__self__, "sigv4", sigv4)

    @property
    @pulumi.getter
    def sigv4(self) -> Optional[pulumi.Input['TopicRuleSigV4AuthorizationArgs']]:
        return pulumi.get(self, "sigv4")

    @sigv4.setter
    def sigv4(self, value: Optional[pulumi.Input['TopicRuleSigV4AuthorizationArgs']]):
        pulumi.set(self, "sigv4", value)


@pulumi.input_type
class TopicRuleIotAnalyticsActionArgs:
    def __init__(__self__, *,
                 channel_name: pulumi.Input[str],
                 role_arn: pulumi.Input[str],
                 batch_mode: Optional[pulumi.Input[bool]] = None):
        pulumi.set(__self__, "channel_name", channel_name)
        pulumi.set(__self__, "role_arn", role_arn)
        if batch_mode is not None:
            pulumi.set(__self__, "batch_mode", batch_mode)

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

    @channel_name.setter
    def channel_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "channel_name", value)

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

    @role_arn.setter
    def role_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "role_arn", value)

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

    @batch_mode.setter
    def batch_mode(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "batch_mode", value)


@pulumi.input_type
class TopicRuleIotEventsActionArgs:
    def __init__(__self__, *,
                 input_name: pulumi.Input[str],
                 role_arn: pulumi.Input[str],
                 batch_mode: Optional[pulumi.Input[bool]] = None,
                 message_id: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "input_name", input_name)
        pulumi.set(__self__, "role_arn", role_arn)
        if batch_mode is not None:
            pulumi.set(__self__, "batch_mode", batch_mode)
        if message_id is not None:
            pulumi.set(__self__, "message_id", message_id)

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

    @input_name.setter
    def input_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "input_name", value)

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

    @role_arn.setter
    def role_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "role_arn", value)

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

    @batch_mode.setter
    def batch_mode(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "batch_mode", value)

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

    @message_id.setter
    def message_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "message_id", value)


@pulumi.input_type
class TopicRuleIotSiteWiseActionArgs:
    def __init__(__self__, *,
                 put_asset_property_value_entries: pulumi.Input[Sequence[pulumi.Input['TopicRulePutAssetPropertyValueEntryArgs']]],
                 role_arn: pulumi.Input[str]):
        pulumi.set(__self__, "put_asset_property_value_entries", put_asset_property_value_entries)
        pulumi.set(__self__, "role_arn", role_arn)

    @property
    @pulumi.getter(name="putAssetPropertyValueEntries")
    def put_asset_property_value_entries(self) -> pulumi.Input[Sequence[pulumi.Input['TopicRulePutAssetPropertyValueEntryArgs']]]:
        return pulumi.get(self, "put_asset_property_value_entries")

    @put_asset_property_value_entries.setter
    def put_asset_property_value_entries(self, value: pulumi.Input[Sequence[pulumi.Input['TopicRulePutAssetPropertyValueEntryArgs']]]):
        pulumi.set(self, "put_asset_property_value_entries", value)

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

    @role_arn.setter
    def role_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "role_arn", value)


@pulumi.input_type
class TopicRuleKafkaActionArgs:
    def __init__(__self__, *,
                 client_properties: Any,
                 destination_arn: pulumi.Input[str],
                 topic: pulumi.Input[str],
                 key: Optional[pulumi.Input[str]] = None,
                 partition: Optional[pulumi.Input[str]] = None):
        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) -> Any:
        return pulumi.get(self, "client_properties")

    @client_properties.setter
    def client_properties(self, value: Any):
        pulumi.set(self, "client_properties", value)

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

    @destination_arn.setter
    def destination_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "destination_arn", value)

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

    @topic.setter
    def topic(self, value: pulumi.Input[str]):
        pulumi.set(self, "topic", value)

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

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

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

    @partition.setter
    def partition(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "partition", value)


@pulumi.input_type
class TopicRuleKinesisActionArgs:
    def __init__(__self__, *,
                 role_arn: pulumi.Input[str],
                 stream_name: pulumi.Input[str],
                 partition_key: Optional[pulumi.Input[str]] = None):
        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) -> pulumi.Input[str]:
        return pulumi.get(self, "role_arn")

    @role_arn.setter
    def role_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "role_arn", value)

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

    @stream_name.setter
    def stream_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "stream_name", value)

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

    @partition_key.setter
    def partition_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "partition_key", value)


@pulumi.input_type
class TopicRuleLambdaActionArgs:
    def __init__(__self__, *,
                 function_arn: Optional[pulumi.Input[str]] = None):
        if function_arn is not None:
            pulumi.set(__self__, "function_arn", function_arn)

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

    @function_arn.setter
    def function_arn(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "function_arn", value)


@pulumi.input_type
class TopicRuleOpenSearchActionArgs:
    def __init__(__self__, *,
                 endpoint: pulumi.Input[str],
                 id: pulumi.Input[str],
                 index: pulumi.Input[str],
                 role_arn: pulumi.Input[str],
                 type: pulumi.Input[str]):
        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) -> pulumi.Input[str]:
        return pulumi.get(self, "endpoint")

    @endpoint.setter
    def endpoint(self, value: pulumi.Input[str]):
        pulumi.set(self, "endpoint", value)

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

    @id.setter
    def id(self, value: pulumi.Input[str]):
        pulumi.set(self, "id", value)

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

    @index.setter
    def index(self, value: pulumi.Input[str]):
        pulumi.set(self, "index", value)

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

    @role_arn.setter
    def role_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "role_arn", value)

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

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class TopicRulePutAssetPropertyValueEntryArgs:
    def __init__(__self__, *,
                 property_values: pulumi.Input[Sequence[pulumi.Input['TopicRuleAssetPropertyValueArgs']]],
                 asset_id: Optional[pulumi.Input[str]] = None,
                 entry_id: Optional[pulumi.Input[str]] = None,
                 property_alias: Optional[pulumi.Input[str]] = None,
                 property_id: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "property_values", property_values)
        if asset_id is not None:
            pulumi.set(__self__, "asset_id", asset_id)
        if entry_id is not None:
            pulumi.set(__self__, "entry_id", entry_id)
        if property_alias is not None:
            pulumi.set(__self__, "property_alias", property_alias)
        if property_id is not None:
            pulumi.set(__self__, "property_id", property_id)

    @property
    @pulumi.getter(name="propertyValues")
    def property_values(self) -> pulumi.Input[Sequence[pulumi.Input['TopicRuleAssetPropertyValueArgs']]]:
        return pulumi.get(self, "property_values")

    @property_values.setter
    def property_values(self, value: pulumi.Input[Sequence[pulumi.Input['TopicRuleAssetPropertyValueArgs']]]):
        pulumi.set(self, "property_values", value)

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

    @asset_id.setter
    def asset_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "asset_id", value)

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

    @entry_id.setter
    def entry_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "entry_id", value)

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

    @property_alias.setter
    def property_alias(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "property_alias", value)

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

    @property_id.setter
    def property_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "property_id", value)


@pulumi.input_type
class TopicRulePutItemInputArgs:
    def __init__(__self__, *,
                 table_name: pulumi.Input[str]):
        pulumi.set(__self__, "table_name", table_name)

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

    @table_name.setter
    def table_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "table_name", value)


@pulumi.input_type
class TopicRuleRepublishActionArgs:
    def __init__(__self__, *,
                 role_arn: pulumi.Input[str],
                 topic: pulumi.Input[str],
                 qos: Optional[pulumi.Input[int]] = None):
        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) -> pulumi.Input[str]:
        return pulumi.get(self, "role_arn")

    @role_arn.setter
    def role_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "role_arn", value)

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

    @topic.setter
    def topic(self, value: pulumi.Input[str]):
        pulumi.set(self, "topic", value)

    @property
    @pulumi.getter
    def qos(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "qos")

    @qos.setter
    def qos(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "qos", value)


@pulumi.input_type
class TopicRuleS3ActionArgs:
    def __init__(__self__, *,
                 bucket_name: pulumi.Input[str],
                 key: pulumi.Input[str],
                 role_arn: pulumi.Input[str],
                 canned_acl: Optional[pulumi.Input['TopicRuleCannedAccessControlList']] = None):
        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) -> pulumi.Input[str]:
        return pulumi.get(self, "bucket_name")

    @bucket_name.setter
    def bucket_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "bucket_name", value)

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

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @role_arn.setter
    def role_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "role_arn", value)

    @property
    @pulumi.getter(name="cannedAcl")
    def canned_acl(self) -> Optional[pulumi.Input['TopicRuleCannedAccessControlList']]:
        return pulumi.get(self, "canned_acl")

    @canned_acl.setter
    def canned_acl(self, value: Optional[pulumi.Input['TopicRuleCannedAccessControlList']]):
        pulumi.set(self, "canned_acl", value)


@pulumi.input_type
class TopicRuleSigV4AuthorizationArgs:
    def __init__(__self__, *,
                 role_arn: pulumi.Input[str],
                 service_name: pulumi.Input[str],
                 signing_region: pulumi.Input[str]):
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "service_name", service_name)
        pulumi.set(__self__, "signing_region", signing_region)

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

    @role_arn.setter
    def role_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "role_arn", value)

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

    @service_name.setter
    def service_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "service_name", value)

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

    @signing_region.setter
    def signing_region(self, value: pulumi.Input[str]):
        pulumi.set(self, "signing_region", value)


@pulumi.input_type
class TopicRuleSnsActionArgs:
    def __init__(__self__, *,
                 role_arn: pulumi.Input[str],
                 target_arn: pulumi.Input[str],
                 message_format: Optional[pulumi.Input[str]] = None):
        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) -> pulumi.Input[str]:
        return pulumi.get(self, "role_arn")

    @role_arn.setter
    def role_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "role_arn", value)

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

    @target_arn.setter
    def target_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "target_arn", value)

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

    @message_format.setter
    def message_format(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "message_format", value)


@pulumi.input_type
class TopicRuleSqsActionArgs:
    def __init__(__self__, *,
                 queue_url: pulumi.Input[str],
                 role_arn: pulumi.Input[str],
                 use_base64: Optional[pulumi.Input[bool]] = None):
        pulumi.set(__self__, "queue_url", queue_url)
        pulumi.set(__self__, "role_arn", role_arn)
        if use_base64 is not None:
            pulumi.set(__self__, "use_base64", use_base64)

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

    @queue_url.setter
    def queue_url(self, value: pulumi.Input[str]):
        pulumi.set(self, "queue_url", value)

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

    @role_arn.setter
    def role_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "role_arn", value)

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

    @use_base64.setter
    def use_base64(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "use_base64", value)


@pulumi.input_type
class TopicRuleStepFunctionsActionArgs:
    def __init__(__self__, *,
                 role_arn: pulumi.Input[str],
                 state_machine_name: pulumi.Input[str],
                 execution_name_prefix: Optional[pulumi.Input[str]] = None):
        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) -> pulumi.Input[str]:
        return pulumi.get(self, "role_arn")

    @role_arn.setter
    def role_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "role_arn", value)

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

    @state_machine_name.setter
    def state_machine_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "state_machine_name", value)

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

    @execution_name_prefix.setter
    def execution_name_prefix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "execution_name_prefix", value)


@pulumi.input_type
class TopicRuleTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class TopicRuleTimestreamActionArgs:
    def __init__(__self__, *,
                 database_name: pulumi.Input[str],
                 dimensions: pulumi.Input[Sequence[pulumi.Input['TopicRuleTimestreamDimensionArgs']]],
                 role_arn: pulumi.Input[str],
                 table_name: pulumi.Input[str],
                 batch_mode: Optional[pulumi.Input[bool]] = None,
                 timestamp: Optional[pulumi.Input['TopicRuleTimestreamTimestampArgs']] = None):
        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 batch_mode is not None:
            pulumi.set(__self__, "batch_mode", batch_mode)
        if timestamp is not None:
            pulumi.set(__self__, "timestamp", timestamp)

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

    @database_name.setter
    def database_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "database_name", value)

    @property
    @pulumi.getter
    def dimensions(self) -> pulumi.Input[Sequence[pulumi.Input['TopicRuleTimestreamDimensionArgs']]]:
        return pulumi.get(self, "dimensions")

    @dimensions.setter
    def dimensions(self, value: pulumi.Input[Sequence[pulumi.Input['TopicRuleTimestreamDimensionArgs']]]):
        pulumi.set(self, "dimensions", value)

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

    @role_arn.setter
    def role_arn(self, value: pulumi.Input[str]):
        pulumi.set(self, "role_arn", value)

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

    @table_name.setter
    def table_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "table_name", value)

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

    @batch_mode.setter
    def batch_mode(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "batch_mode", value)

    @property
    @pulumi.getter
    def timestamp(self) -> Optional[pulumi.Input['TopicRuleTimestreamTimestampArgs']]:
        return pulumi.get(self, "timestamp")

    @timestamp.setter
    def timestamp(self, value: Optional[pulumi.Input['TopicRuleTimestreamTimestampArgs']]):
        pulumi.set(self, "timestamp", value)


@pulumi.input_type
class TopicRuleTimestreamDimensionArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

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

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

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

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class TopicRuleTimestreamTimestampArgs:
    def __init__(__self__, *,
                 unit: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "unit", unit)
        pulumi.set(__self__, "value", value)

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

    @unit.setter
    def unit(self, value: pulumi.Input[str]):
        pulumi.set(self, "unit", value)

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

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class TopicRuleTopicRulePayloadArgs:
    def __init__(__self__, *,
                 actions: pulumi.Input[Sequence[pulumi.Input['TopicRuleActionArgs']]],
                 sql: pulumi.Input[str],
                 aws_iot_sql_version: Optional[pulumi.Input[str]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 error_action: Optional[pulumi.Input['TopicRuleActionArgs']] = None,
                 rule_disabled: Optional[pulumi.Input[bool]] = None):
        pulumi.set(__self__, "actions", actions)
        pulumi.set(__self__, "sql", sql)
        if aws_iot_sql_version is not None:
            pulumi.set(__self__, "aws_iot_sql_version", aws_iot_sql_version)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if error_action is not None:
            pulumi.set(__self__, "error_action", error_action)
        if rule_disabled is not None:
            pulumi.set(__self__, "rule_disabled", rule_disabled)

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

    @actions.setter
    def actions(self, value: pulumi.Input[Sequence[pulumi.Input['TopicRuleActionArgs']]]):
        pulumi.set(self, "actions", value)

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

    @sql.setter
    def sql(self, value: pulumi.Input[str]):
        pulumi.set(self, "sql", value)

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

    @aws_iot_sql_version.setter
    def aws_iot_sql_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "aws_iot_sql_version", value)

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

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)

    @property
    @pulumi.getter(name="errorAction")
    def error_action(self) -> Optional[pulumi.Input['TopicRuleActionArgs']]:
        return pulumi.get(self, "error_action")

    @error_action.setter
    def error_action(self, value: Optional[pulumi.Input['TopicRuleActionArgs']]):
        pulumi.set(self, "error_action", value)

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

    @rule_disabled.setter
    def rule_disabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "rule_disabled", value)


