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

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

__all__ = [
    'ApiDestinationHttpApiParametersArgs',
    'ConnectionAuthParametersArgs',
    'ConnectionAuthParametersApiKeyAuthParametersArgs',
    'ConnectionAuthParametersBasicAuthParametersArgs',
    'ConnectionAuthParametersOauthParametersArgs',
    'ConnectionAuthParametersOauthParametersClientParametersArgs',
    'ConnectionAuthParametersOauthParametersOauthHttpParametersArgs',
    'ConnectionAuthParametersOauthParametersOauthHttpParametersBodyParameterArgs',
    'ConnectionAuthParametersOauthParametersOauthHttpParametersHeaderParameterArgs',
    'ConnectionAuthParametersOauthParametersOauthHttpParametersQueryStringParameterArgs',
    'ConnectionNetworkParametersArgs',
    'RuleTargetArgs',
    'RuleTargetDeadLetterQueueArgs',
    'RuleTargetParamListArgs',
]

@pulumi.input_type
class ApiDestinationHttpApiParametersArgs:
    def __init__(__self__, *,
                 endpoint: pulumi.Input[str],
                 method: pulumi.Input[str]):
        """
        :param pulumi.Input[str] endpoint: The endpoint of the API destination.
        :param pulumi.Input[str] method: The HTTP request method. Valid values: `GET`, `POST`, `HEAD`, `DELETE`, `PUT`, `PATCH`.
        """
        pulumi.set(__self__, "endpoint", endpoint)
        pulumi.set(__self__, "method", method)

    @property
    @pulumi.getter
    def endpoint(self) -> pulumi.Input[str]:
        """
        The endpoint of the API destination.
        """
        return pulumi.get(self, "endpoint")

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

    @property
    @pulumi.getter
    def method(self) -> pulumi.Input[str]:
        """
        The HTTP request method. Valid values: `GET`, `POST`, `HEAD`, `DELETE`, `PUT`, `PATCH`.
        """
        return pulumi.get(self, "method")

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


@pulumi.input_type
class ConnectionAuthParametersArgs:
    def __init__(__self__, *,
                 api_key_auth_parameters: Optional[pulumi.Input['ConnectionAuthParametersApiKeyAuthParametersArgs']] = None,
                 authorization_type: Optional[pulumi.Input[str]] = None,
                 basic_auth_parameters: Optional[pulumi.Input['ConnectionAuthParametersBasicAuthParametersArgs']] = None,
                 oauth_parameters: Optional[pulumi.Input['ConnectionAuthParametersOauthParametersArgs']] = None):
        """
        :param pulumi.Input['ConnectionAuthParametersApiKeyAuthParametersArgs'] api_key_auth_parameters: The parameters that are configured for API key authentication. See `api_key_auth_parameters` below.
        :param pulumi.Input[str] authorization_type: The type of the authentication. Valid values: `API_KEY_AUTH`, `BASIC_AUTH`, `OAUTH_AUTH`.
        :param pulumi.Input['ConnectionAuthParametersBasicAuthParametersArgs'] basic_auth_parameters: The parameters that are configured for basic authentication. See `basic_auth_parameters` below.
        :param pulumi.Input['ConnectionAuthParametersOauthParametersArgs'] oauth_parameters: The parameters that are configured for OAuth authentication. See `oauth_parameters` below.
        """
        if api_key_auth_parameters is not None:
            pulumi.set(__self__, "api_key_auth_parameters", api_key_auth_parameters)
        if authorization_type is not None:
            pulumi.set(__self__, "authorization_type", authorization_type)
        if basic_auth_parameters is not None:
            pulumi.set(__self__, "basic_auth_parameters", basic_auth_parameters)
        if oauth_parameters is not None:
            pulumi.set(__self__, "oauth_parameters", oauth_parameters)

    @property
    @pulumi.getter(name="apiKeyAuthParameters")
    def api_key_auth_parameters(self) -> Optional[pulumi.Input['ConnectionAuthParametersApiKeyAuthParametersArgs']]:
        """
        The parameters that are configured for API key authentication. See `api_key_auth_parameters` below.
        """
        return pulumi.get(self, "api_key_auth_parameters")

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

    @property
    @pulumi.getter(name="authorizationType")
    def authorization_type(self) -> Optional[pulumi.Input[str]]:
        """
        The type of the authentication. Valid values: `API_KEY_AUTH`, `BASIC_AUTH`, `OAUTH_AUTH`.
        """
        return pulumi.get(self, "authorization_type")

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

    @property
    @pulumi.getter(name="basicAuthParameters")
    def basic_auth_parameters(self) -> Optional[pulumi.Input['ConnectionAuthParametersBasicAuthParametersArgs']]:
        """
        The parameters that are configured for basic authentication. See `basic_auth_parameters` below.
        """
        return pulumi.get(self, "basic_auth_parameters")

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

    @property
    @pulumi.getter(name="oauthParameters")
    def oauth_parameters(self) -> Optional[pulumi.Input['ConnectionAuthParametersOauthParametersArgs']]:
        """
        The parameters that are configured for OAuth authentication. See `oauth_parameters` below.
        """
        return pulumi.get(self, "oauth_parameters")

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


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

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

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

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

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


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

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

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

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

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


@pulumi.input_type
class ConnectionAuthParametersOauthParametersArgs:
    def __init__(__self__, *,
                 authorization_endpoint: Optional[pulumi.Input[str]] = None,
                 client_parameters: Optional[pulumi.Input['ConnectionAuthParametersOauthParametersClientParametersArgs']] = None,
                 http_method: Optional[pulumi.Input[str]] = None,
                 oauth_http_parameters: Optional[pulumi.Input['ConnectionAuthParametersOauthParametersOauthHttpParametersArgs']] = None):
        if authorization_endpoint is not None:
            pulumi.set(__self__, "authorization_endpoint", authorization_endpoint)
        if client_parameters is not None:
            pulumi.set(__self__, "client_parameters", client_parameters)
        if http_method is not None:
            pulumi.set(__self__, "http_method", http_method)
        if oauth_http_parameters is not None:
            pulumi.set(__self__, "oauth_http_parameters", oauth_http_parameters)

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

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

    @property
    @pulumi.getter(name="clientParameters")
    def client_parameters(self) -> Optional[pulumi.Input['ConnectionAuthParametersOauthParametersClientParametersArgs']]:
        return pulumi.get(self, "client_parameters")

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

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

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

    @property
    @pulumi.getter(name="oauthHttpParameters")
    def oauth_http_parameters(self) -> Optional[pulumi.Input['ConnectionAuthParametersOauthParametersOauthHttpParametersArgs']]:
        return pulumi.get(self, "oauth_http_parameters")

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


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

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

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

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

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


@pulumi.input_type
class ConnectionAuthParametersOauthParametersOauthHttpParametersArgs:
    def __init__(__self__, *,
                 body_parameters: Optional[pulumi.Input[Sequence[pulumi.Input['ConnectionAuthParametersOauthParametersOauthHttpParametersBodyParameterArgs']]]] = None,
                 header_parameters: Optional[pulumi.Input[Sequence[pulumi.Input['ConnectionAuthParametersOauthParametersOauthHttpParametersHeaderParameterArgs']]]] = None,
                 query_string_parameters: Optional[pulumi.Input[Sequence[pulumi.Input['ConnectionAuthParametersOauthParametersOauthHttpParametersQueryStringParameterArgs']]]] = None):
        if body_parameters is not None:
            pulumi.set(__self__, "body_parameters", body_parameters)
        if header_parameters is not None:
            pulumi.set(__self__, "header_parameters", header_parameters)
        if query_string_parameters is not None:
            pulumi.set(__self__, "query_string_parameters", query_string_parameters)

    @property
    @pulumi.getter(name="bodyParameters")
    def body_parameters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ConnectionAuthParametersOauthParametersOauthHttpParametersBodyParameterArgs']]]]:
        return pulumi.get(self, "body_parameters")

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

    @property
    @pulumi.getter(name="headerParameters")
    def header_parameters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ConnectionAuthParametersOauthParametersOauthHttpParametersHeaderParameterArgs']]]]:
        return pulumi.get(self, "header_parameters")

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

    @property
    @pulumi.getter(name="queryStringParameters")
    def query_string_parameters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ConnectionAuthParametersOauthParametersOauthHttpParametersQueryStringParameterArgs']]]]:
        return pulumi.get(self, "query_string_parameters")

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


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

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

    @is_value_secret.setter
    def is_value_secret(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "is_value_secret", 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 value(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "value")

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


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

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

    @is_value_secret.setter
    def is_value_secret(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "is_value_secret", 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 value(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "value")

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


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

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

    @is_value_secret.setter
    def is_value_secret(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "is_value_secret", 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 value(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "value")

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


@pulumi.input_type
class ConnectionNetworkParametersArgs:
    def __init__(__self__, *,
                 network_type: pulumi.Input[str],
                 security_group_id: Optional[pulumi.Input[str]] = None,
                 vpc_id: Optional[pulumi.Input[str]] = None,
                 vswitche_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] network_type: The network type. Valid values: `PublicNetwork`, `PrivateNetwork`. **NOTE:** If you set `network_type` to `PrivateNetwork`, you must configure `vpc_id`, `vswitche_id`, and `security_group_id`.
        :param pulumi.Input[str] security_group_id: The ID of the security group.
        :param pulumi.Input[str] vpc_id: The ID of the VPC.
        :param pulumi.Input[str] vswitche_id: The ID of the VSwitch.
        """
        pulumi.set(__self__, "network_type", network_type)
        if security_group_id is not None:
            pulumi.set(__self__, "security_group_id", security_group_id)
        if vpc_id is not None:
            pulumi.set(__self__, "vpc_id", vpc_id)
        if vswitche_id is not None:
            pulumi.set(__self__, "vswitche_id", vswitche_id)

    @property
    @pulumi.getter(name="networkType")
    def network_type(self) -> pulumi.Input[str]:
        """
        The network type. Valid values: `PublicNetwork`, `PrivateNetwork`. **NOTE:** If you set `network_type` to `PrivateNetwork`, you must configure `vpc_id`, `vswitche_id`, and `security_group_id`.
        """
        return pulumi.get(self, "network_type")

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

    @property
    @pulumi.getter(name="securityGroupId")
    def security_group_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the security group.
        """
        return pulumi.get(self, "security_group_id")

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

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

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

    @property
    @pulumi.getter(name="vswitcheId")
    def vswitche_id(self) -> Optional[pulumi.Input[str]]:
        """
        The ID of the VSwitch.
        """
        return pulumi.get(self, "vswitche_id")

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


@pulumi.input_type
class RuleTargetArgs:
    def __init__(__self__, *,
                 endpoint: pulumi.Input[str],
                 param_lists: pulumi.Input[Sequence[pulumi.Input['RuleTargetParamListArgs']]],
                 target_id: pulumi.Input[str],
                 type: pulumi.Input[str],
                 dead_letter_queue: Optional[pulumi.Input['RuleTargetDeadLetterQueueArgs']] = None,
                 push_retry_strategy: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] endpoint: The endpoint of the event target.
        :param pulumi.Input[Sequence[pulumi.Input['RuleTargetParamListArgs']]] param_lists: The parameters that are configured for the event target. See `param_list` below.
        :param pulumi.Input[str] target_id: The ID of the custom event target.
        :param pulumi.Input[str] type: The type of the event target. Valid values: `acs.alikafka`, `acs.api.destination`, `acs.arms.loki`, `acs.datahub`, `acs.dingtalk`, `acs.eventbridge`, `acs.eventbridge.olap`, `acs.eventbus.SLSCloudLens`, `acs.fc.function`, `acs.fnf`, `acs.k8s`, `acs.mail`, `acs.mns.queue`, `acs.mns.topic`, `acs.openapi`, `acs.rabbitmq`, `acs.rds.mysql`, `acs.rocketmq`, `acs.sae`, `acs.sls`, `acs.sms`, `http`,`https` and `mysql`.
               **NOTE:** From version 1.208.1, `type` can be set to `acs.alikafka`, `acs.api.destination`, `acs.arms.loki`, `acs.datahub`, `acs.eventbridge.olap`, `acs.eventbus.SLSCloudLens`, `acs.fnf`, `acs.k8s`, `acs.openapi`, `acs.rds.mysql`, `acs.sae`, `acs.sls`, `mysql`.
        :param pulumi.Input['RuleTargetDeadLetterQueueArgs'] dead_letter_queue: The dead letter queue. Events that are not processed or exceed the number of retries will be written to the dead letter. Support message service MNS and message queue RocketMQ. See `dead_letter_queue` below.
        :param pulumi.Input[str] push_retry_strategy: The retry policy that is used to push the event. Valid values:
        """
        pulumi.set(__self__, "endpoint", endpoint)
        pulumi.set(__self__, "param_lists", param_lists)
        pulumi.set(__self__, "target_id", target_id)
        pulumi.set(__self__, "type", type)
        if dead_letter_queue is not None:
            pulumi.set(__self__, "dead_letter_queue", dead_letter_queue)
        if push_retry_strategy is not None:
            pulumi.set(__self__, "push_retry_strategy", push_retry_strategy)

    @property
    @pulumi.getter
    def endpoint(self) -> pulumi.Input[str]:
        """
        The endpoint of the event target.
        """
        return pulumi.get(self, "endpoint")

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

    @property
    @pulumi.getter(name="paramLists")
    def param_lists(self) -> pulumi.Input[Sequence[pulumi.Input['RuleTargetParamListArgs']]]:
        """
        The parameters that are configured for the event target. See `param_list` below.
        """
        return pulumi.get(self, "param_lists")

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

    @property
    @pulumi.getter(name="targetId")
    def target_id(self) -> pulumi.Input[str]:
        """
        The ID of the custom event target.
        """
        return pulumi.get(self, "target_id")

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

    @property
    @pulumi.getter
    def type(self) -> pulumi.Input[str]:
        """
        The type of the event target. Valid values: `acs.alikafka`, `acs.api.destination`, `acs.arms.loki`, `acs.datahub`, `acs.dingtalk`, `acs.eventbridge`, `acs.eventbridge.olap`, `acs.eventbus.SLSCloudLens`, `acs.fc.function`, `acs.fnf`, `acs.k8s`, `acs.mail`, `acs.mns.queue`, `acs.mns.topic`, `acs.openapi`, `acs.rabbitmq`, `acs.rds.mysql`, `acs.rocketmq`, `acs.sae`, `acs.sls`, `acs.sms`, `http`,`https` and `mysql`.
        **NOTE:** From version 1.208.1, `type` can be set to `acs.alikafka`, `acs.api.destination`, `acs.arms.loki`, `acs.datahub`, `acs.eventbridge.olap`, `acs.eventbus.SLSCloudLens`, `acs.fnf`, `acs.k8s`, `acs.openapi`, `acs.rds.mysql`, `acs.sae`, `acs.sls`, `mysql`.
        """
        return pulumi.get(self, "type")

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

    @property
    @pulumi.getter(name="deadLetterQueue")
    def dead_letter_queue(self) -> Optional[pulumi.Input['RuleTargetDeadLetterQueueArgs']]:
        """
        The dead letter queue. Events that are not processed or exceed the number of retries will be written to the dead letter. Support message service MNS and message queue RocketMQ. See `dead_letter_queue` below.
        """
        return pulumi.get(self, "dead_letter_queue")

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

    @property
    @pulumi.getter(name="pushRetryStrategy")
    def push_retry_strategy(self) -> Optional[pulumi.Input[str]]:
        """
        The retry policy that is used to push the event. Valid values:
        """
        return pulumi.get(self, "push_retry_strategy")

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


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

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

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


@pulumi.input_type
class RuleTargetParamListArgs:
    def __init__(__self__, *,
                 form: pulumi.Input[str],
                 resource_key: pulumi.Input[str],
                 template: Optional[pulumi.Input[str]] = None,
                 value: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "form", form)
        pulumi.set(__self__, "resource_key", resource_key)
        if template is not None:
            pulumi.set(__self__, "template", template)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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

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

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

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

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

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

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


