# 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 sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from .. import _utilities

__all__ = [
    'ApiDestinationHttpApiParametersArgs',
    'ApiDestinationHttpApiParametersArgsDict',
    'ConnectionAuthParametersArgs',
    'ConnectionAuthParametersArgsDict',
    'ConnectionAuthParametersApiKeyAuthParametersArgs',
    'ConnectionAuthParametersApiKeyAuthParametersArgsDict',
    'ConnectionAuthParametersBasicAuthParametersArgs',
    'ConnectionAuthParametersBasicAuthParametersArgsDict',
    'ConnectionAuthParametersOauthParametersArgs',
    'ConnectionAuthParametersOauthParametersArgsDict',
    'ConnectionAuthParametersOauthParametersClientParametersArgs',
    'ConnectionAuthParametersOauthParametersClientParametersArgsDict',
    'ConnectionAuthParametersOauthParametersOauthHttpParametersArgs',
    'ConnectionAuthParametersOauthParametersOauthHttpParametersArgsDict',
    'ConnectionAuthParametersOauthParametersOauthHttpParametersBodyParameterArgs',
    'ConnectionAuthParametersOauthParametersOauthHttpParametersBodyParameterArgsDict',
    'ConnectionAuthParametersOauthParametersOauthHttpParametersHeaderParameterArgs',
    'ConnectionAuthParametersOauthParametersOauthHttpParametersHeaderParameterArgsDict',
    'ConnectionAuthParametersOauthParametersOauthHttpParametersQueryStringParameterArgs',
    'ConnectionAuthParametersOauthParametersOauthHttpParametersQueryStringParameterArgsDict',
    'ConnectionNetworkParametersArgs',
    'ConnectionNetworkParametersArgsDict',
    'RuleTargetArgs',
    'RuleTargetArgsDict',
    'RuleTargetDeadLetterQueueArgs',
    'RuleTargetDeadLetterQueueArgsDict',
    'RuleTargetParamListArgs',
    'RuleTargetParamListArgsDict',
]

MYPY = False

if not MYPY:
    class ApiDestinationHttpApiParametersArgsDict(TypedDict):
        endpoint: pulumi.Input[str]
        """
        The endpoint of the API destination.
        """
        method: pulumi.Input[str]
        """
        The HTTP request method. Valid values: `GET`, `POST`, `HEAD`, `DELETE`, `PUT`, `PATCH`.
        """
elif False:
    ApiDestinationHttpApiParametersArgsDict: TypeAlias = Mapping[str, Any]

@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)


if not MYPY:
    class ConnectionAuthParametersArgsDict(TypedDict):
        api_key_auth_parameters: NotRequired[pulumi.Input['ConnectionAuthParametersApiKeyAuthParametersArgsDict']]
        """
        The parameters that are configured for API key authentication. See `api_key_auth_parameters` below.
        """
        authorization_type: NotRequired[pulumi.Input[str]]
        """
        The type of the authentication. Valid values: `API_KEY_AUTH`, `BASIC_AUTH`, `OAUTH_AUTH`.
        """
        basic_auth_parameters: NotRequired[pulumi.Input['ConnectionAuthParametersBasicAuthParametersArgsDict']]
        """
        The parameters that are configured for basic authentication. See `basic_auth_parameters` below.
        """
        oauth_parameters: NotRequired[pulumi.Input['ConnectionAuthParametersOauthParametersArgsDict']]
        """
        The parameters that are configured for OAuth authentication. See `oauth_parameters` below.
        """
elif False:
    ConnectionAuthParametersArgsDict: TypeAlias = Mapping[str, Any]

@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)


if not MYPY:
    class ConnectionAuthParametersApiKeyAuthParametersArgsDict(TypedDict):
        api_key_name: NotRequired[pulumi.Input[str]]
        """
        The name of the API key.
        """
        api_key_value: NotRequired[pulumi.Input[str]]
        """
        The value of the API key.
        """
elif False:
    ConnectionAuthParametersApiKeyAuthParametersArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ConnectionAuthParametersApiKeyAuthParametersArgs:
    def __init__(__self__, *,
                 api_key_name: Optional[pulumi.Input[str]] = None,
                 api_key_value: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] api_key_name: The name of the API key.
        :param pulumi.Input[str] api_key_value: The value of the API key.
        """
        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]]:
        """
        The name of the API key.
        """
        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]]:
        """
        The value of the API key.
        """
        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)


if not MYPY:
    class ConnectionAuthParametersBasicAuthParametersArgsDict(TypedDict):
        password: NotRequired[pulumi.Input[str]]
        """
        The password for basic authentication.
        """
        username: NotRequired[pulumi.Input[str]]
        """
        The username for basic authentication.
        """
elif False:
    ConnectionAuthParametersBasicAuthParametersArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ConnectionAuthParametersBasicAuthParametersArgs:
    def __init__(__self__, *,
                 password: Optional[pulumi.Input[str]] = None,
                 username: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] password: The password for basic authentication.
        :param pulumi.Input[str] username: The username for basic authentication.
        """
        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]]:
        """
        The password for basic authentication.
        """
        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]]:
        """
        The username for basic authentication.
        """
        return pulumi.get(self, "username")

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


if not MYPY:
    class ConnectionAuthParametersOauthParametersArgsDict(TypedDict):
        authorization_endpoint: NotRequired[pulumi.Input[str]]
        """
        The IP address of the authorized endpoint.
        """
        client_parameters: NotRequired[pulumi.Input['ConnectionAuthParametersOauthParametersClientParametersArgsDict']]
        """
        The parameters that are configured for the client. See `client_parameters` below.
        """
        http_method: NotRequired[pulumi.Input[str]]
        """
        The HTTP request method. Valid values: `GET`, `POST`, `HEAD`, `DELETE`, `PUT`, `PATCH`.
        """
        oauth_http_parameters: NotRequired[pulumi.Input['ConnectionAuthParametersOauthParametersOauthHttpParametersArgsDict']]
        """
        The request parameters that are configured for OAuth authentication. See `oauth_http_parameters` below.
        """
elif False:
    ConnectionAuthParametersOauthParametersArgsDict: TypeAlias = Mapping[str, Any]

@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):
        """
        :param pulumi.Input[str] authorization_endpoint: The IP address of the authorized endpoint.
        :param pulumi.Input['ConnectionAuthParametersOauthParametersClientParametersArgs'] client_parameters: The parameters that are configured for the client. See `client_parameters` below.
        :param pulumi.Input[str] http_method: The HTTP request method. Valid values: `GET`, `POST`, `HEAD`, `DELETE`, `PUT`, `PATCH`.
        :param pulumi.Input['ConnectionAuthParametersOauthParametersOauthHttpParametersArgs'] oauth_http_parameters: The request parameters that are configured for OAuth authentication. See `oauth_http_parameters` below.
        """
        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]]:
        """
        The IP address of the authorized endpoint.
        """
        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']]:
        """
        The parameters that are configured for the client. See `client_parameters` below.
        """
        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]]:
        """
        The HTTP request method. Valid values: `GET`, `POST`, `HEAD`, `DELETE`, `PUT`, `PATCH`.
        """
        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']]:
        """
        The request parameters that are configured for OAuth authentication. See `oauth_http_parameters` below.
        """
        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)


if not MYPY:
    class ConnectionAuthParametersOauthParametersClientParametersArgsDict(TypedDict):
        client_id: NotRequired[pulumi.Input[str]]
        """
        The ID of the client.
        """
        client_secret: NotRequired[pulumi.Input[str]]
        """
        The AccessKey secret of the client.
        """
elif False:
    ConnectionAuthParametersOauthParametersClientParametersArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ConnectionAuthParametersOauthParametersClientParametersArgs:
    def __init__(__self__, *,
                 client_id: Optional[pulumi.Input[str]] = None,
                 client_secret: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] client_id: The ID of the client.
        :param pulumi.Input[str] client_secret: The AccessKey secret of the client.
        """
        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]]:
        """
        The ID of the client.
        """
        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]]:
        """
        The AccessKey secret of the client.
        """
        return pulumi.get(self, "client_secret")

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


if not MYPY:
    class ConnectionAuthParametersOauthParametersOauthHttpParametersArgsDict(TypedDict):
        body_parameters: NotRequired[pulumi.Input[Sequence[pulumi.Input['ConnectionAuthParametersOauthParametersOauthHttpParametersBodyParameterArgsDict']]]]
        """
        The parameters that are configured for the request body. See `body_parameters` below.
        """
        header_parameters: NotRequired[pulumi.Input[Sequence[pulumi.Input['ConnectionAuthParametersOauthParametersOauthHttpParametersHeaderParameterArgsDict']]]]
        """
        The parameters that are configured for the request header. See `header_parameters` below.
        """
        query_string_parameters: NotRequired[pulumi.Input[Sequence[pulumi.Input['ConnectionAuthParametersOauthParametersOauthHttpParametersQueryStringParameterArgsDict']]]]
        """
        The parameters that are configured for the request path. See `query_string_parameters` below.
        """
elif False:
    ConnectionAuthParametersOauthParametersOauthHttpParametersArgsDict: TypeAlias = Mapping[str, Any]

@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):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ConnectionAuthParametersOauthParametersOauthHttpParametersBodyParameterArgs']]] body_parameters: The parameters that are configured for the request body. See `body_parameters` below.
        :param pulumi.Input[Sequence[pulumi.Input['ConnectionAuthParametersOauthParametersOauthHttpParametersHeaderParameterArgs']]] header_parameters: The parameters that are configured for the request header. See `header_parameters` below.
        :param pulumi.Input[Sequence[pulumi.Input['ConnectionAuthParametersOauthParametersOauthHttpParametersQueryStringParameterArgs']]] query_string_parameters: The parameters that are configured for the request path. See `query_string_parameters` below.
        """
        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']]]]:
        """
        The parameters that are configured for the request body. See `body_parameters` below.
        """
        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']]]]:
        """
        The parameters that are configured for the request header. See `header_parameters` below.
        """
        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']]]]:
        """
        The parameters that are configured for the request path. See `query_string_parameters` below.
        """
        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)


if not MYPY:
    class ConnectionAuthParametersOauthParametersOauthHttpParametersBodyParameterArgsDict(TypedDict):
        is_value_secret: NotRequired[pulumi.Input[str]]
        """
        Specifies whether to enable authentication.
        """
        key: NotRequired[pulumi.Input[str]]
        """
        The key of the request path.
        """
        value: NotRequired[pulumi.Input[str]]
        """
        The key of the request path.
        """
elif False:
    ConnectionAuthParametersOauthParametersOauthHttpParametersBodyParameterArgsDict: TypeAlias = Mapping[str, Any]

@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):
        """
        :param pulumi.Input[str] is_value_secret: Specifies whether to enable authentication.
        :param pulumi.Input[str] key: The key of the request path.
        :param pulumi.Input[str] value: The key of the request path.
        """
        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]]:
        """
        Specifies whether to enable authentication.
        """
        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]]:
        """
        The key of the request path.
        """
        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]]:
        """
        The key of the request path.
        """
        return pulumi.get(self, "value")

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


if not MYPY:
    class ConnectionAuthParametersOauthParametersOauthHttpParametersHeaderParameterArgsDict(TypedDict):
        is_value_secret: NotRequired[pulumi.Input[str]]
        """
        Specifies whether to enable authentication.
        """
        key: NotRequired[pulumi.Input[str]]
        """
        The key of the request path.
        """
        value: NotRequired[pulumi.Input[str]]
        """
        The key of the request path.
        """
elif False:
    ConnectionAuthParametersOauthParametersOauthHttpParametersHeaderParameterArgsDict: TypeAlias = Mapping[str, Any]

@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):
        """
        :param pulumi.Input[str] is_value_secret: Specifies whether to enable authentication.
        :param pulumi.Input[str] key: The key of the request path.
        :param pulumi.Input[str] value: The key of the request path.
        """
        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]]:
        """
        Specifies whether to enable authentication.
        """
        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]]:
        """
        The key of the request path.
        """
        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]]:
        """
        The key of the request path.
        """
        return pulumi.get(self, "value")

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


if not MYPY:
    class ConnectionAuthParametersOauthParametersOauthHttpParametersQueryStringParameterArgsDict(TypedDict):
        is_value_secret: NotRequired[pulumi.Input[str]]
        """
        Specifies whether to enable authentication.
        """
        key: NotRequired[pulumi.Input[str]]
        """
        The key of the request path.
        """
        value: NotRequired[pulumi.Input[str]]
        """
        The key of the request path.
        """
elif False:
    ConnectionAuthParametersOauthParametersOauthHttpParametersQueryStringParameterArgsDict: TypeAlias = Mapping[str, Any]

@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):
        """
        :param pulumi.Input[str] is_value_secret: Specifies whether to enable authentication.
        :param pulumi.Input[str] key: The key of the request path.
        :param pulumi.Input[str] value: The key of the request path.
        """
        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]]:
        """
        Specifies whether to enable authentication.
        """
        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]]:
        """
        The key of the request path.
        """
        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]]:
        """
        The key of the request path.
        """
        return pulumi.get(self, "value")

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


if not MYPY:
    class ConnectionNetworkParametersArgsDict(TypedDict):
        network_type: 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`.
        """
        security_group_id: NotRequired[pulumi.Input[str]]
        """
        The ID of the security group.
        """
        vpc_id: NotRequired[pulumi.Input[str]]
        """
        The ID of the VPC.
        """
        vswitche_id: NotRequired[pulumi.Input[str]]
        """
        The ID of the VSwitch.
        """
elif False:
    ConnectionNetworkParametersArgsDict: TypeAlias = Mapping[str, Any]

@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)


if not MYPY:
    class RuleTargetArgsDict(TypedDict):
        endpoint: pulumi.Input[str]
        """
        The endpoint of the event target.
        """
        param_lists: pulumi.Input[Sequence[pulumi.Input['RuleTargetParamListArgsDict']]]
        """
        The parameters that are configured for the event target. See `param_list` below.
        """
        target_id: pulumi.Input[str]
        """
        The ID of the custom event target.
        """
        type: 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`.
        """
        dead_letter_queue: NotRequired[pulumi.Input['RuleTargetDeadLetterQueueArgsDict']]
        """
        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.
        """
        push_retry_strategy: NotRequired[pulumi.Input[str]]
        """
        The retry policy that is used to push the event. Valid values:
        - `BACKOFF_RETRY`: Backoff retry. The request can be retried up to three times. The interval between two consecutive retries is a random value between 10 and 20 seconds.
        - `EXPONENTIAL_DECAY_RETRY`: Exponential decay retry. The request can be retried up to 176 times. The interval between two consecutive retries exponentially increases to 512 seconds, and the total retry time is one day. The specific retry intervals are 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 512, ..., and 512 seconds, including a maximum of one hundred and sixty-seven 512 seconds in total.
        """
elif False:
    RuleTargetArgsDict: TypeAlias = Mapping[str, Any]

@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:
               - `BACKOFF_RETRY`: Backoff retry. The request can be retried up to three times. The interval between two consecutive retries is a random value between 10 and 20 seconds.
               - `EXPONENTIAL_DECAY_RETRY`: Exponential decay retry. The request can be retried up to 176 times. The interval between two consecutive retries exponentially increases to 512 seconds, and the total retry time is one day. The specific retry intervals are 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 512, ..., and 512 seconds, including a maximum of one hundred and sixty-seven 512 seconds in total.
        """
        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:
        - `BACKOFF_RETRY`: Backoff retry. The request can be retried up to three times. The interval between two consecutive retries is a random value between 10 and 20 seconds.
        - `EXPONENTIAL_DECAY_RETRY`: Exponential decay retry. The request can be retried up to 176 times. The interval between two consecutive retries exponentially increases to 512 seconds, and the total retry time is one day. The specific retry intervals are 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 512, ..., and 512 seconds, including a maximum of one hundred and sixty-seven 512 seconds in total.
        """
        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)


if not MYPY:
    class RuleTargetDeadLetterQueueArgsDict(TypedDict):
        arn: NotRequired[pulumi.Input[str]]
        """
        The Alibaba Cloud Resource Name (ARN) of the dead letter queue. Events that are not processed or whose maximum retries are exceeded are written to the dead-letter queue. The ARN feature is supported by the following queue types: MNS and Message Queue for Apache RocketMQ.
        """
elif False:
    RuleTargetDeadLetterQueueArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RuleTargetDeadLetterQueueArgs:
    def __init__(__self__, *,
                 arn: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] arn: The Alibaba Cloud Resource Name (ARN) of the dead letter queue. Events that are not processed or whose maximum retries are exceeded are written to the dead-letter queue. The ARN feature is supported by the following queue types: MNS and Message Queue for Apache RocketMQ.
        """
        if arn is not None:
            pulumi.set(__self__, "arn", arn)

    @property
    @pulumi.getter
    def arn(self) -> Optional[pulumi.Input[str]]:
        """
        The Alibaba Cloud Resource Name (ARN) of the dead letter queue. Events that are not processed or whose maximum retries are exceeded are written to the dead-letter queue. The ARN feature is supported by the following queue types: MNS and Message Queue for Apache RocketMQ.
        """
        return pulumi.get(self, "arn")

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


if not MYPY:
    class RuleTargetParamListArgsDict(TypedDict):
        form: pulumi.Input[str]
        """
        The format of the event target parameter. Valid values: `ORIGINAL`, `TEMPLATE`, `JSONPATH`, `CONSTANT`.
        """
        resource_key: pulumi.Input[str]
        """
        The resource parameter of the event target. For more information, see [How to use it](https://www.alibabacloud.com/help/en/eventbridge/latest/event-target-parameters)
        """
        template: NotRequired[pulumi.Input[str]]
        """
        The template of the event target parameter.
        """
        value: NotRequired[pulumi.Input[str]]
        """
        The value of the event target parameter.

        > **NOTE:** There exists a potential diff error that the backend service will return a default param as following:

        ```
        param_list {
        resource_key = "IsBase64Encode"
        form         = "CONSTANT"
        value        = "false"
        template     = ""
        }
        ```

        In order to fix the diff, from version 1.160.0, this resource has removed the param which `resource_key = "IsBase64Encode"` and `value = "false"`.
        If you want to set `resource_key = "IsBase64Encode"`, please avoid to set `value = "false"`.
        """
elif False:
    RuleTargetParamListArgsDict: TypeAlias = Mapping[str, Any]

@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):
        """
        :param pulumi.Input[str] form: The format of the event target parameter. Valid values: `ORIGINAL`, `TEMPLATE`, `JSONPATH`, `CONSTANT`.
        :param pulumi.Input[str] resource_key: The resource parameter of the event target. For more information, see [How to use it](https://www.alibabacloud.com/help/en/eventbridge/latest/event-target-parameters)
        :param pulumi.Input[str] template: The template of the event target parameter.
        :param pulumi.Input[str] value: The value of the event target parameter.
               
               > **NOTE:** There exists a potential diff error that the backend service will return a default param as following:
               
               ```
               param_list {
               resource_key = "IsBase64Encode"
               form         = "CONSTANT"
               value        = "false"
               template     = ""
               }
               ```
               
               In order to fix the diff, from version 1.160.0, this resource has removed the param which `resource_key = "IsBase64Encode"` and `value = "false"`.
               If you want to set `resource_key = "IsBase64Encode"`, please avoid to set `value = "false"`.
        """
        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]:
        """
        The format of the event target parameter. Valid values: `ORIGINAL`, `TEMPLATE`, `JSONPATH`, `CONSTANT`.
        """
        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]:
        """
        The resource parameter of the event target. For more information, see [How to use it](https://www.alibabacloud.com/help/en/eventbridge/latest/event-target-parameters)
        """
        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]]:
        """
        The template of the event target parameter.
        """
        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]]:
        """
        The value of the event target parameter.

        > **NOTE:** There exists a potential diff error that the backend service will return a default param as following:

        ```
        param_list {
        resource_key = "IsBase64Encode"
        form         = "CONSTANT"
        value        = "false"
        template     = ""
        }
        ```

        In order to fix the diff, from version 1.160.0, this resource has removed the param which `resource_key = "IsBase64Encode"` and `value = "false"`.
        If you want to set `resource_key = "IsBase64Encode"`, please avoid to set `value = "false"`.
        """
        return pulumi.get(self, "value")

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


