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

import builtins
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
from . import outputs

__all__ = [
    'AliasRoutingConfig',
    'CustomDomainCertConfig',
    'CustomDomainRouteConfig',
    'FunctionAsyncInvokeConfigDestinationConfig',
    'FunctionAsyncInvokeConfigDestinationConfigOnFailure',
    'FunctionAsyncInvokeConfigDestinationConfigOnSuccess',
    'FunctionCustomContainerConfig',
    'ServiceLogConfig',
    'ServiceNasConfig',
    'ServiceNasConfigMountPoint',
    'ServiceTracingConfig',
    'ServiceVpcConfig',
    'V2FunctionCode',
    'V2FunctionCustomContainerConfig',
    'V2FunctionCustomDns',
    'V2FunctionCustomDnsDnsOption',
    'V2FunctionCustomHealthCheckConfig',
    'V2FunctionCustomRuntimeConfig',
    'V2FunctionInstanceLifecycleConfig',
    'V2FunctionInstanceLifecycleConfigPreFreeze',
    'V2FunctionInstanceLifecycleConfigPreStop',
    'V3AsyncInvokeConfigDestinationConfig',
    'V3AsyncInvokeConfigDestinationConfigOnFailure',
    'V3AsyncInvokeConfigDestinationConfigOnSuccess',
    'V3CustomDomainAuthConfig',
    'V3CustomDomainCertConfig',
    'V3CustomDomainRouteConfig',
    'V3CustomDomainRouteConfigRoute',
    'V3CustomDomainRouteConfigRouteRewriteConfig',
    'V3CustomDomainRouteConfigRouteRewriteConfigEqualRule',
    'V3CustomDomainRouteConfigRouteRewriteConfigRegexRule',
    'V3CustomDomainRouteConfigRouteRewriteConfigWildcardRule',
    'V3CustomDomainTlsConfig',
    'V3CustomDomainWafConfig',
    'V3FunctionCode',
    'V3FunctionCustomContainerConfig',
    'V3FunctionCustomContainerConfigAccelerationInfo',
    'V3FunctionCustomContainerConfigHealthCheckConfig',
    'V3FunctionCustomDns',
    'V3FunctionCustomDnsDnsOption',
    'V3FunctionCustomRuntimeConfig',
    'V3FunctionCustomRuntimeConfigHealthCheckConfig',
    'V3FunctionGpuConfig',
    'V3FunctionInstanceLifecycleConfig',
    'V3FunctionInstanceLifecycleConfigInitializer',
    'V3FunctionInstanceLifecycleConfigPreStop',
    'V3FunctionLogConfig',
    'V3FunctionNasConfig',
    'V3FunctionNasConfigMountPoint',
    'V3FunctionOssMountConfig',
    'V3FunctionOssMountConfigMountPoint',
    'V3FunctionTracingConfig',
    'V3FunctionVpcConfig',
    'V3LayerVersionCode',
    'V3ProvisionConfigScheduledAction',
    'V3ProvisionConfigTargetTrackingPolicy',
    'V3TriggerHttpTrigger',
    'GetCustomDomainsDomainResult',
    'GetCustomDomainsDomainCertConfigResult',
    'GetCustomDomainsDomainRouteConfigResult',
    'GetFunctionsFunctionResult',
    'GetFunctionsFunctionCustomContainerConfigResult',
    'GetServicesServiceResult',
    'GetServicesServiceLogConfigResult',
    'GetServicesServiceNasConfigResult',
    'GetServicesServiceNasConfigMountPointResult',
    'GetServicesServiceVpcConfigResult',
    'GetTriggersTriggerResult',
    'GetV3TriggersTriggerResult',
    'GetV3TriggersTriggerHttpTriggerResult',
    'GetZonesZoneResult',
]

@pulumi.output_type
class AliasRoutingConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "additionalVersionWeights":
            suggest = "additional_version_weights"

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

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

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

    def __init__(__self__, *,
                 additional_version_weights: Optional[Mapping[str, builtins.float]] = None):
        """
        :param Mapping[str, builtins.float] additional_version_weights: A map that defines the proportion of events that should be sent to different versions of a Function Compute service.
        """
        if additional_version_weights is not None:
            pulumi.set(__self__, "additional_version_weights", additional_version_weights)

    @property
    @pulumi.getter(name="additionalVersionWeights")
    def additional_version_weights(self) -> Optional[Mapping[str, builtins.float]]:
        """
        A map that defines the proportion of events that should be sent to different versions of a Function Compute service.
        """
        return pulumi.get(self, "additional_version_weights")


@pulumi.output_type
class CustomDomainCertConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "certName":
            suggest = "cert_name"
        elif key == "privateKey":
            suggest = "private_key"

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

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

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

    def __init__(__self__, *,
                 cert_name: builtins.str,
                 certificate: builtins.str,
                 private_key: builtins.str):
        """
        :param builtins.str cert_name: The name of the certificate, used to distinguish different certificates.
        :param builtins.str certificate: Certificate data of the HTTPS certificates, follow the 'pem' format.
        :param builtins.str private_key: Private key of the HTTPS certificates, follow the 'pem' format.
        """
        pulumi.set(__self__, "cert_name", cert_name)
        pulumi.set(__self__, "certificate", certificate)
        pulumi.set(__self__, "private_key", private_key)

    @property
    @pulumi.getter(name="certName")
    def cert_name(self) -> builtins.str:
        """
        The name of the certificate, used to distinguish different certificates.
        """
        return pulumi.get(self, "cert_name")

    @property
    @pulumi.getter
    def certificate(self) -> builtins.str:
        """
        Certificate data of the HTTPS certificates, follow the 'pem' format.
        """
        return pulumi.get(self, "certificate")

    @property
    @pulumi.getter(name="privateKey")
    def private_key(self) -> builtins.str:
        """
        Private key of the HTTPS certificates, follow the 'pem' format.
        """
        return pulumi.get(self, "private_key")


@pulumi.output_type
class CustomDomainRouteConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "functionName":
            suggest = "function_name"
        elif key == "serviceName":
            suggest = "service_name"

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

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

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

    def __init__(__self__, *,
                 function_name: builtins.str,
                 path: builtins.str,
                 service_name: builtins.str,
                 methods: Optional[Sequence[builtins.str]] = None,
                 qualifier: Optional[builtins.str] = None):
        """
        :param builtins.str function_name: The name of the Function Compute function that requests are routed to.
        :param builtins.str path: The path that requests are routed from.
        :param builtins.str service_name: The name of the Function Compute service that requests are routed to.
        :param Sequence[builtins.str] methods: The requests of the specified HTTP methos are routed from. Valid method: GET, POST, DELETE, HEAD, PUT and PATCH. For example, "GET, HEAD" methods indicate that only requests from GET and HEAD methods are routed.
        :param builtins.str qualifier: The version or alias of the Function Compute service that requests are routed to. For example, qualifier v1 indicates that the requests are routed to the version 1 Function Compute service. For detail information about version and alias, please refer to the [developer guide](https://www.alibabacloud.com/help/doc-detail/96464.htm).
        """
        pulumi.set(__self__, "function_name", function_name)
        pulumi.set(__self__, "path", path)
        pulumi.set(__self__, "service_name", service_name)
        if methods is not None:
            pulumi.set(__self__, "methods", methods)
        if qualifier is not None:
            pulumi.set(__self__, "qualifier", qualifier)

    @property
    @pulumi.getter(name="functionName")
    def function_name(self) -> builtins.str:
        """
        The name of the Function Compute function that requests are routed to.
        """
        return pulumi.get(self, "function_name")

    @property
    @pulumi.getter
    def path(self) -> builtins.str:
        """
        The path that requests are routed from.
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter(name="serviceName")
    def service_name(self) -> builtins.str:
        """
        The name of the Function Compute service that requests are routed to.
        """
        return pulumi.get(self, "service_name")

    @property
    @pulumi.getter
    def methods(self) -> Optional[Sequence[builtins.str]]:
        """
        The requests of the specified HTTP methos are routed from. Valid method: GET, POST, DELETE, HEAD, PUT and PATCH. For example, "GET, HEAD" methods indicate that only requests from GET and HEAD methods are routed.
        """
        return pulumi.get(self, "methods")

    @property
    @pulumi.getter
    def qualifier(self) -> Optional[builtins.str]:
        """
        The version or alias of the Function Compute service that requests are routed to. For example, qualifier v1 indicates that the requests are routed to the version 1 Function Compute service. For detail information about version and alias, please refer to the [developer guide](https://www.alibabacloud.com/help/doc-detail/96464.htm).
        """
        return pulumi.get(self, "qualifier")


@pulumi.output_type
class FunctionAsyncInvokeConfigDestinationConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "onFailure":
            suggest = "on_failure"
        elif key == "onSuccess":
            suggest = "on_success"

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

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

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

    def __init__(__self__, *,
                 on_failure: Optional['outputs.FunctionAsyncInvokeConfigDestinationConfigOnFailure'] = None,
                 on_success: Optional['outputs.FunctionAsyncInvokeConfigDestinationConfigOnSuccess'] = None):
        """
        :param 'FunctionAsyncInvokeConfigDestinationConfigOnFailureArgs' on_failure: Configuration block with destination configuration for failed asynchronous invocations. See `on_failure` below.
        :param 'FunctionAsyncInvokeConfigDestinationConfigOnSuccessArgs' on_success: Configuration block with destination configuration for successful asynchronous invocations. See `on_success` below.
        """
        if on_failure is not None:
            pulumi.set(__self__, "on_failure", on_failure)
        if on_success is not None:
            pulumi.set(__self__, "on_success", on_success)

    @property
    @pulumi.getter(name="onFailure")
    def on_failure(self) -> Optional['outputs.FunctionAsyncInvokeConfigDestinationConfigOnFailure']:
        """
        Configuration block with destination configuration for failed asynchronous invocations. See `on_failure` below.
        """
        return pulumi.get(self, "on_failure")

    @property
    @pulumi.getter(name="onSuccess")
    def on_success(self) -> Optional['outputs.FunctionAsyncInvokeConfigDestinationConfigOnSuccess']:
        """
        Configuration block with destination configuration for successful asynchronous invocations. See `on_success` below.
        """
        return pulumi.get(self, "on_success")


@pulumi.output_type
class FunctionAsyncInvokeConfigDestinationConfigOnFailure(dict):
    def __init__(__self__, *,
                 destination: builtins.str):
        """
        :param builtins.str destination: Alicloud Resource Name (ARN) of the destination resource. See the [Developer Guide](https://www.alibabacloud.com/help/doc-detail/181866.htm) for acceptable resource types and associated RAM permissions.
        """
        pulumi.set(__self__, "destination", destination)

    @property
    @pulumi.getter
    def destination(self) -> builtins.str:
        """
        Alicloud Resource Name (ARN) of the destination resource. See the [Developer Guide](https://www.alibabacloud.com/help/doc-detail/181866.htm) for acceptable resource types and associated RAM permissions.
        """
        return pulumi.get(self, "destination")


@pulumi.output_type
class FunctionAsyncInvokeConfigDestinationConfigOnSuccess(dict):
    def __init__(__self__, *,
                 destination: builtins.str):
        """
        :param builtins.str destination: Alicloud Resource Name (ARN) of the destination resource. See the [Developer Guide](https://www.alibabacloud.com/help/doc-detail/181866.htm) for acceptable resource types and associated RAM permissions.
        """
        pulumi.set(__self__, "destination", destination)

    @property
    @pulumi.getter
    def destination(self) -> builtins.str:
        """
        Alicloud Resource Name (ARN) of the destination resource. See the [Developer Guide](https://www.alibabacloud.com/help/doc-detail/181866.htm) for acceptable resource types and associated RAM permissions.
        """
        return pulumi.get(self, "destination")


@pulumi.output_type
class FunctionCustomContainerConfig(dict):
    def __init__(__self__, *,
                 image: builtins.str,
                 args: Optional[builtins.str] = None,
                 command: Optional[builtins.str] = None):
        """
        :param builtins.str image: The container image address.
        :param builtins.str args: The args field specifies the arguments passed to the command.
        :param builtins.str command: The entry point of the container, which specifies the actual command run by the container.
        """
        pulumi.set(__self__, "image", image)
        if args is not None:
            pulumi.set(__self__, "args", args)
        if command is not None:
            pulumi.set(__self__, "command", command)

    @property
    @pulumi.getter
    def image(self) -> builtins.str:
        """
        The container image address.
        """
        return pulumi.get(self, "image")

    @property
    @pulumi.getter
    def args(self) -> Optional[builtins.str]:
        """
        The args field specifies the arguments passed to the command.
        """
        return pulumi.get(self, "args")

    @property
    @pulumi.getter
    def command(self) -> Optional[builtins.str]:
        """
        The entry point of the container, which specifies the actual command run by the container.
        """
        return pulumi.get(self, "command")


@pulumi.output_type
class ServiceLogConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enableInstanceMetrics":
            suggest = "enable_instance_metrics"
        elif key == "enableRequestMetrics":
            suggest = "enable_request_metrics"

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

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

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

    def __init__(__self__, *,
                 logstore: builtins.str,
                 project: builtins.str,
                 enable_instance_metrics: Optional[builtins.bool] = None,
                 enable_request_metrics: Optional[builtins.bool] = None):
        """
        :param builtins.str logstore: The log store name of Alicloud Simple Log Service.
        :param builtins.str project: The project name of the Alicloud Simple Log Service.
        :param builtins.bool enable_instance_metrics: Enable instance level metrics.
        :param builtins.bool enable_request_metrics: Enable request level metrics.
        """
        pulumi.set(__self__, "logstore", logstore)
        pulumi.set(__self__, "project", project)
        if enable_instance_metrics is not None:
            pulumi.set(__self__, "enable_instance_metrics", enable_instance_metrics)
        if enable_request_metrics is not None:
            pulumi.set(__self__, "enable_request_metrics", enable_request_metrics)

    @property
    @pulumi.getter
    def logstore(self) -> builtins.str:
        """
        The log store name of Alicloud Simple Log Service.
        """
        return pulumi.get(self, "logstore")

    @property
    @pulumi.getter
    def project(self) -> builtins.str:
        """
        The project name of the Alicloud Simple Log Service.
        """
        return pulumi.get(self, "project")

    @property
    @pulumi.getter(name="enableInstanceMetrics")
    def enable_instance_metrics(self) -> Optional[builtins.bool]:
        """
        Enable instance level metrics.
        """
        return pulumi.get(self, "enable_instance_metrics")

    @property
    @pulumi.getter(name="enableRequestMetrics")
    def enable_request_metrics(self) -> Optional[builtins.bool]:
        """
        Enable request level metrics.
        """
        return pulumi.get(self, "enable_request_metrics")


@pulumi.output_type
class ServiceNasConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "groupId":
            suggest = "group_id"
        elif key == "mountPoints":
            suggest = "mount_points"
        elif key == "userId":
            suggest = "user_id"

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

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

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

    def __init__(__self__, *,
                 group_id: builtins.int,
                 mount_points: Sequence['outputs.ServiceNasConfigMountPoint'],
                 user_id: builtins.int):
        """
        :param builtins.int group_id: The group id of your NAS file system.
        :param Sequence['ServiceNasConfigMountPointArgs'] mount_points: Config the NAS mount points.See `mount_points` below.
        :param builtins.int user_id: The user id of your NAS file system.
        """
        pulumi.set(__self__, "group_id", group_id)
        pulumi.set(__self__, "mount_points", mount_points)
        pulumi.set(__self__, "user_id", user_id)

    @property
    @pulumi.getter(name="groupId")
    def group_id(self) -> builtins.int:
        """
        The group id of your NAS file system.
        """
        return pulumi.get(self, "group_id")

    @property
    @pulumi.getter(name="mountPoints")
    def mount_points(self) -> Sequence['outputs.ServiceNasConfigMountPoint']:
        """
        Config the NAS mount points.See `mount_points` below.
        """
        return pulumi.get(self, "mount_points")

    @property
    @pulumi.getter(name="userId")
    def user_id(self) -> builtins.int:
        """
        The user id of your NAS file system.
        """
        return pulumi.get(self, "user_id")


@pulumi.output_type
class ServiceNasConfigMountPoint(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "mountDir":
            suggest = "mount_dir"
        elif key == "serverAddr":
            suggest = "server_addr"

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

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

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

    def __init__(__self__, *,
                 mount_dir: builtins.str,
                 server_addr: builtins.str):
        """
        :param builtins.str mount_dir: The local address where to mount your remote NAS directory.
        :param builtins.str server_addr: The address of the remote NAS directory.
        """
        pulumi.set(__self__, "mount_dir", mount_dir)
        pulumi.set(__self__, "server_addr", server_addr)

    @property
    @pulumi.getter(name="mountDir")
    def mount_dir(self) -> builtins.str:
        """
        The local address where to mount your remote NAS directory.
        """
        return pulumi.get(self, "mount_dir")

    @property
    @pulumi.getter(name="serverAddr")
    def server_addr(self) -> builtins.str:
        """
        The address of the remote NAS directory.
        """
        return pulumi.get(self, "server_addr")


@pulumi.output_type
class ServiceTracingConfig(dict):
    def __init__(__self__, *,
                 params: Mapping[str, builtins.str],
                 type: builtins.str):
        """
        :param Mapping[str, builtins.str] params: Tracing parameters, which type is map[string]string. When the protocol type is Jaeger, the key is "endpoint" and the value is your tracing intranet endpoint. For example endpoint: http://tracing-analysis-dc-hz.aliyuncs.com/adapt_xxx/api/traces.
        :param builtins.str type: Tracing protocol type. Currently, only Jaeger is supported.
        """
        pulumi.set(__self__, "params", params)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def params(self) -> Mapping[str, builtins.str]:
        """
        Tracing parameters, which type is map[string]string. When the protocol type is Jaeger, the key is "endpoint" and the value is your tracing intranet endpoint. For example endpoint: http://tracing-analysis-dc-hz.aliyuncs.com/adapt_xxx/api/traces.
        """
        return pulumi.get(self, "params")

    @property
    @pulumi.getter
    def type(self) -> builtins.str:
        """
        Tracing protocol type. Currently, only Jaeger is supported.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class ServiceVpcConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "securityGroupId":
            suggest = "security_group_id"
        elif key == "vswitchIds":
            suggest = "vswitch_ids"
        elif key == "vpcId":
            suggest = "vpc_id"

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

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

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

    def __init__(__self__, *,
                 security_group_id: builtins.str,
                 vswitch_ids: Sequence[builtins.str],
                 vpc_id: Optional[builtins.str] = None):
        """
        :param builtins.str security_group_id: A security group ID associated with the Function Compute Service.
        :param Sequence[builtins.str] vswitch_ids: A list of vswitch IDs associated with the Function Compute Service.
        :param builtins.str vpc_id: A vpc ID associated with the Function Compute Service.
        """
        pulumi.set(__self__, "security_group_id", security_group_id)
        pulumi.set(__self__, "vswitch_ids", vswitch_ids)
        if vpc_id is not None:
            pulumi.set(__self__, "vpc_id", vpc_id)

    @property
    @pulumi.getter(name="securityGroupId")
    def security_group_id(self) -> builtins.str:
        """
        A security group ID associated with the Function Compute Service.
        """
        return pulumi.get(self, "security_group_id")

    @property
    @pulumi.getter(name="vswitchIds")
    def vswitch_ids(self) -> Sequence[builtins.str]:
        """
        A list of vswitch IDs associated with the Function Compute Service.
        """
        return pulumi.get(self, "vswitch_ids")

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> Optional[builtins.str]:
        """
        A vpc ID associated with the Function Compute Service.
        """
        return pulumi.get(self, "vpc_id")


@pulumi.output_type
class V2FunctionCode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ossBucketName":
            suggest = "oss_bucket_name"
        elif key == "ossObjectName":
            suggest = "oss_object_name"
        elif key == "zipFile":
            suggest = "zip_file"

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

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

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

    def __init__(__self__, *,
                 oss_bucket_name: Optional[builtins.str] = None,
                 oss_object_name: Optional[builtins.str] = None,
                 zip_file: Optional[builtins.str] = None):
        """
        :param builtins.str oss_bucket_name: The OSS bucket name of the function code package.
        :param builtins.str oss_object_name: The OSS object name of the function code package.
        :param builtins.str zip_file: Upload the base64 encoding of the code zip package directly in the request body.
        """
        if oss_bucket_name is not None:
            pulumi.set(__self__, "oss_bucket_name", oss_bucket_name)
        if oss_object_name is not None:
            pulumi.set(__self__, "oss_object_name", oss_object_name)
        if zip_file is not None:
            pulumi.set(__self__, "zip_file", zip_file)

    @property
    @pulumi.getter(name="ossBucketName")
    def oss_bucket_name(self) -> Optional[builtins.str]:
        """
        The OSS bucket name of the function code package.
        """
        return pulumi.get(self, "oss_bucket_name")

    @property
    @pulumi.getter(name="ossObjectName")
    def oss_object_name(self) -> Optional[builtins.str]:
        """
        The OSS object name of the function code package.
        """
        return pulumi.get(self, "oss_object_name")

    @property
    @pulumi.getter(name="zipFile")
    def zip_file(self) -> Optional[builtins.str]:
        """
        Upload the base64 encoding of the code zip package directly in the request body.
        """
        return pulumi.get(self, "zip_file")


@pulumi.output_type
class V2FunctionCustomContainerConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accelerationType":
            suggest = "acceleration_type"
        elif key == "webServerMode":
            suggest = "web_server_mode"

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

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

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

    def __init__(__self__, *,
                 acceleration_type: Optional[builtins.str] = None,
                 args: Optional[builtins.str] = None,
                 command: Optional[builtins.str] = None,
                 image: Optional[builtins.str] = None,
                 web_server_mode: Optional[builtins.bool] = None):
        """
        :param builtins.str acceleration_type: Image acceleration type. The value Default is to enable acceleration and None is to disable acceleration.
        :param builtins.str args: Container startup parameters.
        :param builtins.str command: Container start command, equivalent to Docker ENTRYPOINT.
        :param builtins.str image: Container Image address. Example value: registry-vpc.cn-hangzhou.aliyuncs.com/fc-demo/helloworld:v1beta1.
        :param builtins.bool web_server_mode: Whether the image is run in Web Server mode. The value of true needs to implement the Web Server in the container image to listen to the port and process the request. The value of false needs to actively exit the process after the container runs, and the ExitCode needs to be 0. Default true.
        """
        if acceleration_type is not None:
            pulumi.set(__self__, "acceleration_type", acceleration_type)
        if args is not None:
            pulumi.set(__self__, "args", args)
        if command is not None:
            pulumi.set(__self__, "command", command)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if web_server_mode is not None:
            pulumi.set(__self__, "web_server_mode", web_server_mode)

    @property
    @pulumi.getter(name="accelerationType")
    def acceleration_type(self) -> Optional[builtins.str]:
        """
        Image acceleration type. The value Default is to enable acceleration and None is to disable acceleration.
        """
        return pulumi.get(self, "acceleration_type")

    @property
    @pulumi.getter
    def args(self) -> Optional[builtins.str]:
        """
        Container startup parameters.
        """
        return pulumi.get(self, "args")

    @property
    @pulumi.getter
    def command(self) -> Optional[builtins.str]:
        """
        Container start command, equivalent to Docker ENTRYPOINT.
        """
        return pulumi.get(self, "command")

    @property
    @pulumi.getter
    def image(self) -> Optional[builtins.str]:
        """
        Container Image address. Example value: registry-vpc.cn-hangzhou.aliyuncs.com/fc-demo/helloworld:v1beta1.
        """
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="webServerMode")
    def web_server_mode(self) -> Optional[builtins.bool]:
        """
        Whether the image is run in Web Server mode. The value of true needs to implement the Web Server in the container image to listen to the port and process the request. The value of false needs to actively exit the process after the container runs, and the ExitCode needs to be 0. Default true.
        """
        return pulumi.get(self, "web_server_mode")


@pulumi.output_type
class V2FunctionCustomDns(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dnsOptions":
            suggest = "dns_options"
        elif key == "nameServers":
            suggest = "name_servers"

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

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

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

    def __init__(__self__, *,
                 dns_options: Optional[Sequence['outputs.V2FunctionCustomDnsDnsOption']] = None,
                 name_servers: Optional[Sequence[builtins.str]] = None,
                 searches: Optional[Sequence[builtins.str]] = None):
        """
        :param Sequence['V2FunctionCustomDnsDnsOptionArgs'] dns_options: DNS resolver configuration parameter list. See `dns_options` below.
        :param Sequence[builtins.str] name_servers: List of IP addresses of DNS servers.
        :param Sequence[builtins.str] searches: List of DNS search domains.
        """
        if dns_options is not None:
            pulumi.set(__self__, "dns_options", dns_options)
        if name_servers is not None:
            pulumi.set(__self__, "name_servers", name_servers)
        if searches is not None:
            pulumi.set(__self__, "searches", searches)

    @property
    @pulumi.getter(name="dnsOptions")
    def dns_options(self) -> Optional[Sequence['outputs.V2FunctionCustomDnsDnsOption']]:
        """
        DNS resolver configuration parameter list. See `dns_options` below.
        """
        return pulumi.get(self, "dns_options")

    @property
    @pulumi.getter(name="nameServers")
    def name_servers(self) -> Optional[Sequence[builtins.str]]:
        """
        List of IP addresses of DNS servers.
        """
        return pulumi.get(self, "name_servers")

    @property
    @pulumi.getter
    def searches(self) -> Optional[Sequence[builtins.str]]:
        """
        List of DNS search domains.
        """
        return pulumi.get(self, "searches")


@pulumi.output_type
class V2FunctionCustomDnsDnsOption(dict):
    def __init__(__self__, *,
                 name: Optional[builtins.str] = None,
                 value: Optional[builtins.str] = None):
        """
        :param builtins.str name: DNS option name.
        :param builtins.str value: DNS option value.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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


@pulumi.output_type
class V2FunctionCustomHealthCheckConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "failureThreshold":
            suggest = "failure_threshold"
        elif key == "httpGetUrl":
            suggest = "http_get_url"
        elif key == "initialDelaySeconds":
            suggest = "initial_delay_seconds"
        elif key == "periodSeconds":
            suggest = "period_seconds"
        elif key == "successThreshold":
            suggest = "success_threshold"
        elif key == "timeoutSeconds":
            suggest = "timeout_seconds"

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

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

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

    def __init__(__self__, *,
                 failure_threshold: Optional[builtins.int] = None,
                 http_get_url: Optional[builtins.str] = None,
                 initial_delay_seconds: Optional[builtins.int] = None,
                 period_seconds: Optional[builtins.int] = None,
                 success_threshold: Optional[builtins.int] = None,
                 timeout_seconds: Optional[builtins.int] = None):
        """
        :param builtins.int failure_threshold: The threshold for the number of health check failures. The system considers the check failed after the health check fails.
        :param builtins.str http_get_url: Container custom health check URL address.
        :param builtins.int initial_delay_seconds: Delay from container startup to initiation of health check.
        :param builtins.int period_seconds: Health check cycle.
        :param builtins.int success_threshold: The threshold for the number of successful health checks. After the health check is reached, the system considers the check successful.
        :param builtins.int timeout_seconds: Health check timeout.
        """
        if failure_threshold is not None:
            pulumi.set(__self__, "failure_threshold", failure_threshold)
        if http_get_url is not None:
            pulumi.set(__self__, "http_get_url", http_get_url)
        if initial_delay_seconds is not None:
            pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
        if period_seconds is not None:
            pulumi.set(__self__, "period_seconds", period_seconds)
        if success_threshold is not None:
            pulumi.set(__self__, "success_threshold", success_threshold)
        if timeout_seconds is not None:
            pulumi.set(__self__, "timeout_seconds", timeout_seconds)

    @property
    @pulumi.getter(name="failureThreshold")
    def failure_threshold(self) -> Optional[builtins.int]:
        """
        The threshold for the number of health check failures. The system considers the check failed after the health check fails.
        """
        return pulumi.get(self, "failure_threshold")

    @property
    @pulumi.getter(name="httpGetUrl")
    def http_get_url(self) -> Optional[builtins.str]:
        """
        Container custom health check URL address.
        """
        return pulumi.get(self, "http_get_url")

    @property
    @pulumi.getter(name="initialDelaySeconds")
    def initial_delay_seconds(self) -> Optional[builtins.int]:
        """
        Delay from container startup to initiation of health check.
        """
        return pulumi.get(self, "initial_delay_seconds")

    @property
    @pulumi.getter(name="periodSeconds")
    def period_seconds(self) -> Optional[builtins.int]:
        """
        Health check cycle.
        """
        return pulumi.get(self, "period_seconds")

    @property
    @pulumi.getter(name="successThreshold")
    def success_threshold(self) -> Optional[builtins.int]:
        """
        The threshold for the number of successful health checks. After the health check is reached, the system considers the check successful.
        """
        return pulumi.get(self, "success_threshold")

    @property
    @pulumi.getter(name="timeoutSeconds")
    def timeout_seconds(self) -> Optional[builtins.int]:
        """
        Health check timeout.
        """
        return pulumi.get(self, "timeout_seconds")


@pulumi.output_type
class V2FunctionCustomRuntimeConfig(dict):
    def __init__(__self__, *,
                 args: Optional[Sequence[builtins.str]] = None,
                 commands: Optional[Sequence[builtins.str]] = None):
        """
        :param Sequence[builtins.str] args: Parameters received by the start entry command.
        :param Sequence[builtins.str] commands: List of Custom entry commands started by Custom Runtime. When there are multiple commands in the list, they are spliced in sequence.
        """
        if args is not None:
            pulumi.set(__self__, "args", args)
        if commands is not None:
            pulumi.set(__self__, "commands", commands)

    @property
    @pulumi.getter
    def args(self) -> Optional[Sequence[builtins.str]]:
        """
        Parameters received by the start entry command.
        """
        return pulumi.get(self, "args")

    @property
    @pulumi.getter
    def commands(self) -> Optional[Sequence[builtins.str]]:
        """
        List of Custom entry commands started by Custom Runtime. When there are multiple commands in the list, they are spliced in sequence.
        """
        return pulumi.get(self, "commands")


@pulumi.output_type
class V2FunctionInstanceLifecycleConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "preFreeze":
            suggest = "pre_freeze"
        elif key == "preStop":
            suggest = "pre_stop"

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

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

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

    def __init__(__self__, *,
                 pre_freeze: Optional['outputs.V2FunctionInstanceLifecycleConfigPreFreeze'] = None,
                 pre_stop: Optional['outputs.V2FunctionInstanceLifecycleConfigPreStop'] = None):
        """
        :param 'V2FunctionInstanceLifecycleConfigPreFreezeArgs' pre_freeze: PreFreeze function configuration. See `pre_freeze` below.
        :param 'V2FunctionInstanceLifecycleConfigPreStopArgs' pre_stop: PreStop function configuration. See `pre_stop` below.
        """
        if pre_freeze is not None:
            pulumi.set(__self__, "pre_freeze", pre_freeze)
        if pre_stop is not None:
            pulumi.set(__self__, "pre_stop", pre_stop)

    @property
    @pulumi.getter(name="preFreeze")
    def pre_freeze(self) -> Optional['outputs.V2FunctionInstanceLifecycleConfigPreFreeze']:
        """
        PreFreeze function configuration. See `pre_freeze` below.
        """
        return pulumi.get(self, "pre_freeze")

    @property
    @pulumi.getter(name="preStop")
    def pre_stop(self) -> Optional['outputs.V2FunctionInstanceLifecycleConfigPreStop']:
        """
        PreStop function configuration. See `pre_stop` below.
        """
        return pulumi.get(self, "pre_stop")


@pulumi.output_type
class V2FunctionInstanceLifecycleConfigPreFreeze(dict):
    def __init__(__self__, *,
                 handler: Optional[builtins.str] = None,
                 timeout: Optional[builtins.int] = None):
        """
        :param builtins.str handler: entry point of function.
        :param builtins.int timeout: max running time of function.
        """
        if handler is not None:
            pulumi.set(__self__, "handler", handler)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter
    def handler(self) -> Optional[builtins.str]:
        """
        entry point of function.
        """
        return pulumi.get(self, "handler")

    @property
    @pulumi.getter
    def timeout(self) -> Optional[builtins.int]:
        """
        max running time of function.
        """
        return pulumi.get(self, "timeout")


@pulumi.output_type
class V2FunctionInstanceLifecycleConfigPreStop(dict):
    def __init__(__self__, *,
                 handler: Optional[builtins.str] = None,
                 timeout: Optional[builtins.int] = None):
        """
        :param builtins.str handler: entry point of function.
        :param builtins.int timeout: max running time of function.
        """
        if handler is not None:
            pulumi.set(__self__, "handler", handler)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter
    def handler(self) -> Optional[builtins.str]:
        """
        entry point of function.
        """
        return pulumi.get(self, "handler")

    @property
    @pulumi.getter
    def timeout(self) -> Optional[builtins.int]:
        """
        max running time of function.
        """
        return pulumi.get(self, "timeout")


@pulumi.output_type
class V3AsyncInvokeConfigDestinationConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "onFailure":
            suggest = "on_failure"
        elif key == "onSuccess":
            suggest = "on_success"

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

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

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

    def __init__(__self__, *,
                 on_failure: Optional['outputs.V3AsyncInvokeConfigDestinationConfigOnFailure'] = None,
                 on_success: Optional['outputs.V3AsyncInvokeConfigDestinationConfigOnSuccess'] = None):
        """
        :param 'V3AsyncInvokeConfigDestinationConfigOnFailureArgs' on_failure: Failed callback target structure See `on_failure` below.
        :param 'V3AsyncInvokeConfigDestinationConfigOnSuccessArgs' on_success: Successful callback target structure See `on_success` below.
        """
        if on_failure is not None:
            pulumi.set(__self__, "on_failure", on_failure)
        if on_success is not None:
            pulumi.set(__self__, "on_success", on_success)

    @property
    @pulumi.getter(name="onFailure")
    def on_failure(self) -> Optional['outputs.V3AsyncInvokeConfigDestinationConfigOnFailure']:
        """
        Failed callback target structure See `on_failure` below.
        """
        return pulumi.get(self, "on_failure")

    @property
    @pulumi.getter(name="onSuccess")
    def on_success(self) -> Optional['outputs.V3AsyncInvokeConfigDestinationConfigOnSuccess']:
        """
        Successful callback target structure See `on_success` below.
        """
        return pulumi.get(self, "on_success")


@pulumi.output_type
class V3AsyncInvokeConfigDestinationConfigOnFailure(dict):
    def __init__(__self__, *,
                 destination: Optional[builtins.str] = None):
        """
        :param builtins.str destination: Asynchronous call target Resource Descriptor
        """
        if destination is not None:
            pulumi.set(__self__, "destination", destination)

    @property
    @pulumi.getter
    def destination(self) -> Optional[builtins.str]:
        """
        Asynchronous call target Resource Descriptor
        """
        return pulumi.get(self, "destination")


@pulumi.output_type
class V3AsyncInvokeConfigDestinationConfigOnSuccess(dict):
    def __init__(__self__, *,
                 destination: Optional[builtins.str] = None):
        """
        :param builtins.str destination: Asynchronous call target Resource Descriptor
        """
        if destination is not None:
            pulumi.set(__self__, "destination", destination)

    @property
    @pulumi.getter
    def destination(self) -> Optional[builtins.str]:
        """
        Asynchronous call target Resource Descriptor
        """
        return pulumi.get(self, "destination")


@pulumi.output_type
class V3CustomDomainAuthConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "authInfo":
            suggest = "auth_info"
        elif key == "authType":
            suggest = "auth_type"

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

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

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

    def __init__(__self__, *,
                 auth_info: Optional[builtins.str] = None,
                 auth_type: Optional[builtins.str] = None):
        """
        :param builtins.str auth_info: Authentication Information
        :param builtins.str auth_type: Authentication type. anonymous, function, or jwt.
        """
        if auth_info is not None:
            pulumi.set(__self__, "auth_info", auth_info)
        if auth_type is not None:
            pulumi.set(__self__, "auth_type", auth_type)

    @property
    @pulumi.getter(name="authInfo")
    def auth_info(self) -> Optional[builtins.str]:
        """
        Authentication Information
        """
        return pulumi.get(self, "auth_info")

    @property
    @pulumi.getter(name="authType")
    def auth_type(self) -> Optional[builtins.str]:
        """
        Authentication type. anonymous, function, or jwt.
        """
        return pulumi.get(self, "auth_type")


@pulumi.output_type
class V3CustomDomainCertConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "certName":
            suggest = "cert_name"
        elif key == "privateKey":
            suggest = "private_key"

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

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

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

    def __init__(__self__, *,
                 cert_name: Optional[builtins.str] = None,
                 certificate: Optional[builtins.str] = None,
                 private_key: Optional[builtins.str] = None):
        """
        :param builtins.str cert_name: Certificate Name
        :param builtins.str certificate: PEM format certificate
        :param builtins.str private_key: Private Key in PEM format
        """
        if cert_name is not None:
            pulumi.set(__self__, "cert_name", cert_name)
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if private_key is not None:
            pulumi.set(__self__, "private_key", private_key)

    @property
    @pulumi.getter(name="certName")
    def cert_name(self) -> Optional[builtins.str]:
        """
        Certificate Name
        """
        return pulumi.get(self, "cert_name")

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

    @property
    @pulumi.getter(name="privateKey")
    def private_key(self) -> Optional[builtins.str]:
        """
        Private Key in PEM format
        """
        return pulumi.get(self, "private_key")


@pulumi.output_type
class V3CustomDomainRouteConfig(dict):
    def __init__(__self__, *,
                 routes: Optional[Sequence['outputs.V3CustomDomainRouteConfigRoute']] = None):
        """
        :param Sequence['V3CustomDomainRouteConfigRouteArgs'] routes: Routing Configuration List See `routes` below.
        """
        if routes is not None:
            pulumi.set(__self__, "routes", routes)

    @property
    @pulumi.getter
    def routes(self) -> Optional[Sequence['outputs.V3CustomDomainRouteConfigRoute']]:
        """
        Routing Configuration List See `routes` below.
        """
        return pulumi.get(self, "routes")


@pulumi.output_type
class V3CustomDomainRouteConfigRoute(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "functionName":
            suggest = "function_name"
        elif key == "rewriteConfig":
            suggest = "rewrite_config"

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

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

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

    def __init__(__self__, *,
                 function_name: Optional[builtins.str] = None,
                 methods: Optional[Sequence[builtins.str]] = None,
                 path: Optional[builtins.str] = None,
                 qualifier: Optional[builtins.str] = None,
                 rewrite_config: Optional['outputs.V3CustomDomainRouteConfigRouteRewriteConfig'] = None):
        """
        :param builtins.str function_name: Function name
        :param Sequence[builtins.str] methods: List of supported HTTP methods
        :param builtins.str path: Route matching rule
        :param builtins.str qualifier: Version or Alias
        :param 'V3CustomDomainRouteConfigRouteRewriteConfigArgs' rewrite_config: Override Configuration See `rewrite_config` below.
        """
        if function_name is not None:
            pulumi.set(__self__, "function_name", function_name)
        if methods is not None:
            pulumi.set(__self__, "methods", methods)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if qualifier is not None:
            pulumi.set(__self__, "qualifier", qualifier)
        if rewrite_config is not None:
            pulumi.set(__self__, "rewrite_config", rewrite_config)

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

    @property
    @pulumi.getter
    def methods(self) -> Optional[Sequence[builtins.str]]:
        """
        List of supported HTTP methods
        """
        return pulumi.get(self, "methods")

    @property
    @pulumi.getter
    def path(self) -> Optional[builtins.str]:
        """
        Route matching rule
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def qualifier(self) -> Optional[builtins.str]:
        """
        Version or Alias
        """
        return pulumi.get(self, "qualifier")

    @property
    @pulumi.getter(name="rewriteConfig")
    def rewrite_config(self) -> Optional['outputs.V3CustomDomainRouteConfigRouteRewriteConfig']:
        """
        Override Configuration See `rewrite_config` below.
        """
        return pulumi.get(self, "rewrite_config")


@pulumi.output_type
class V3CustomDomainRouteConfigRouteRewriteConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "equalRules":
            suggest = "equal_rules"
        elif key == "regexRules":
            suggest = "regex_rules"
        elif key == "wildcardRules":
            suggest = "wildcard_rules"

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

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

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

    def __init__(__self__, *,
                 equal_rules: Optional[Sequence['outputs.V3CustomDomainRouteConfigRouteRewriteConfigEqualRule']] = None,
                 regex_rules: Optional[Sequence['outputs.V3CustomDomainRouteConfigRouteRewriteConfigRegexRule']] = None,
                 wildcard_rules: Optional[Sequence['outputs.V3CustomDomainRouteConfigRouteRewriteConfigWildcardRule']] = None):
        """
        :param Sequence['V3CustomDomainRouteConfigRouteRewriteConfigEqualRuleArgs'] equal_rules: Exact Match Rule List See `equal_rules` below.
        :param Sequence['V3CustomDomainRouteConfigRouteRewriteConfigRegexRuleArgs'] regex_rules: Regular match rule list See `regex_rules` below.
        :param Sequence['V3CustomDomainRouteConfigRouteRewriteConfigWildcardRuleArgs'] wildcard_rules: List of wildcard matching rules See `wildcard_rules` below.
        """
        if equal_rules is not None:
            pulumi.set(__self__, "equal_rules", equal_rules)
        if regex_rules is not None:
            pulumi.set(__self__, "regex_rules", regex_rules)
        if wildcard_rules is not None:
            pulumi.set(__self__, "wildcard_rules", wildcard_rules)

    @property
    @pulumi.getter(name="equalRules")
    def equal_rules(self) -> Optional[Sequence['outputs.V3CustomDomainRouteConfigRouteRewriteConfigEqualRule']]:
        """
        Exact Match Rule List See `equal_rules` below.
        """
        return pulumi.get(self, "equal_rules")

    @property
    @pulumi.getter(name="regexRules")
    def regex_rules(self) -> Optional[Sequence['outputs.V3CustomDomainRouteConfigRouteRewriteConfigRegexRule']]:
        """
        Regular match rule list See `regex_rules` below.
        """
        return pulumi.get(self, "regex_rules")

    @property
    @pulumi.getter(name="wildcardRules")
    def wildcard_rules(self) -> Optional[Sequence['outputs.V3CustomDomainRouteConfigRouteRewriteConfigWildcardRule']]:
        """
        List of wildcard matching rules See `wildcard_rules` below.
        """
        return pulumi.get(self, "wildcard_rules")


@pulumi.output_type
class V3CustomDomainRouteConfigRouteRewriteConfigEqualRule(dict):
    def __init__(__self__, *,
                 match: Optional[builtins.str] = None,
                 replacement: Optional[builtins.str] = None):
        """
        :param builtins.str match: Matching Rules
        :param builtins.str replacement: Replace Rules
        """
        if match is not None:
            pulumi.set(__self__, "match", match)
        if replacement is not None:
            pulumi.set(__self__, "replacement", replacement)

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

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


@pulumi.output_type
class V3CustomDomainRouteConfigRouteRewriteConfigRegexRule(dict):
    def __init__(__self__, *,
                 match: Optional[builtins.str] = None,
                 replacement: Optional[builtins.str] = None):
        """
        :param builtins.str match: Matching Rules
        :param builtins.str replacement: Replace Rules
        """
        if match is not None:
            pulumi.set(__self__, "match", match)
        if replacement is not None:
            pulumi.set(__self__, "replacement", replacement)

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

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


@pulumi.output_type
class V3CustomDomainRouteConfigRouteRewriteConfigWildcardRule(dict):
    def __init__(__self__, *,
                 match: Optional[builtins.str] = None,
                 replacement: Optional[builtins.str] = None):
        """
        :param builtins.str match: Matching Rules
        :param builtins.str replacement: Replace Rules
        """
        if match is not None:
            pulumi.set(__self__, "match", match)
        if replacement is not None:
            pulumi.set(__self__, "replacement", replacement)

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

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


@pulumi.output_type
class V3CustomDomainTlsConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cipherSuites":
            suggest = "cipher_suites"
        elif key == "maxVersion":
            suggest = "max_version"
        elif key == "minVersion":
            suggest = "min_version"

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

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

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

    def __init__(__self__, *,
                 cipher_suites: Optional[Sequence[builtins.str]] = None,
                 max_version: Optional[builtins.str] = None,
                 min_version: Optional[builtins.str] = None):
        """
        :param Sequence[builtins.str] cipher_suites: List of TLS cipher suites
        :param builtins.str max_version: The maximum version of TLS. Enumeration values: TLSv1.3, TLSv1.2, TLSv1.1, TLSv1.0
        :param builtins.str min_version: TLS minimum version number. Enumeration values: TLSv1.3, TLSv1.2, TLSv1.1, TLSv1.0
        """
        if cipher_suites is not None:
            pulumi.set(__self__, "cipher_suites", cipher_suites)
        if max_version is not None:
            pulumi.set(__self__, "max_version", max_version)
        if min_version is not None:
            pulumi.set(__self__, "min_version", min_version)

    @property
    @pulumi.getter(name="cipherSuites")
    def cipher_suites(self) -> Optional[Sequence[builtins.str]]:
        """
        List of TLS cipher suites
        """
        return pulumi.get(self, "cipher_suites")

    @property
    @pulumi.getter(name="maxVersion")
    def max_version(self) -> Optional[builtins.str]:
        """
        The maximum version of TLS. Enumeration values: TLSv1.3, TLSv1.2, TLSv1.1, TLSv1.0
        """
        return pulumi.get(self, "max_version")

    @property
    @pulumi.getter(name="minVersion")
    def min_version(self) -> Optional[builtins.str]:
        """
        TLS minimum version number. Enumeration values: TLSv1.3, TLSv1.2, TLSv1.1, TLSv1.0
        """
        return pulumi.get(self, "min_version")


@pulumi.output_type
class V3CustomDomainWafConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enableWaf":
            suggest = "enable_waf"

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

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

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

    def __init__(__self__, *,
                 enable_waf: Optional[builtins.bool] = None):
        """
        :param builtins.bool enable_waf: Enable WAF protection
        """
        if enable_waf is not None:
            pulumi.set(__self__, "enable_waf", enable_waf)

    @property
    @pulumi.getter(name="enableWaf")
    def enable_waf(self) -> Optional[builtins.bool]:
        """
        Enable WAF protection
        """
        return pulumi.get(self, "enable_waf")


@pulumi.output_type
class V3FunctionCode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ossBucketName":
            suggest = "oss_bucket_name"
        elif key == "ossObjectName":
            suggest = "oss_object_name"
        elif key == "zipFile":
            suggest = "zip_file"

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

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

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

    def __init__(__self__, *,
                 checksum: Optional[builtins.str] = None,
                 oss_bucket_name: Optional[builtins.str] = None,
                 oss_object_name: Optional[builtins.str] = None,
                 zip_file: Optional[builtins.str] = None):
        """
        :param builtins.str checksum: The CRC-64 value of the function code package.
        :param builtins.str oss_bucket_name: The name of the OSS Bucket that stores the function code ZIP package.
        :param builtins.str oss_object_name: The name of the OSS Object that stores the function code ZIP package.
        :param builtins.str zip_file: The Base 64 encoding of the function code ZIP package.
        """
        if checksum is not None:
            pulumi.set(__self__, "checksum", checksum)
        if oss_bucket_name is not None:
            pulumi.set(__self__, "oss_bucket_name", oss_bucket_name)
        if oss_object_name is not None:
            pulumi.set(__self__, "oss_object_name", oss_object_name)
        if zip_file is not None:
            pulumi.set(__self__, "zip_file", zip_file)

    @property
    @pulumi.getter
    def checksum(self) -> Optional[builtins.str]:
        """
        The CRC-64 value of the function code package.
        """
        return pulumi.get(self, "checksum")

    @property
    @pulumi.getter(name="ossBucketName")
    def oss_bucket_name(self) -> Optional[builtins.str]:
        """
        The name of the OSS Bucket that stores the function code ZIP package.
        """
        return pulumi.get(self, "oss_bucket_name")

    @property
    @pulumi.getter(name="ossObjectName")
    def oss_object_name(self) -> Optional[builtins.str]:
        """
        The name of the OSS Object that stores the function code ZIP package.
        """
        return pulumi.get(self, "oss_object_name")

    @property
    @pulumi.getter(name="zipFile")
    def zip_file(self) -> Optional[builtins.str]:
        """
        The Base 64 encoding of the function code ZIP package.
        """
        return pulumi.get(self, "zip_file")


@pulumi.output_type
class V3FunctionCustomContainerConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accelerationInfo":
            suggest = "acceleration_info"
        elif key == "accelerationType":
            suggest = "acceleration_type"
        elif key == "acrInstanceId":
            suggest = "acr_instance_id"
        elif key == "healthCheckConfig":
            suggest = "health_check_config"
        elif key == "resolvedImageUri":
            suggest = "resolved_image_uri"

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

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

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

    def __init__(__self__, *,
                 acceleration_info: Optional['outputs.V3FunctionCustomContainerConfigAccelerationInfo'] = None,
                 acceleration_type: Optional[builtins.str] = None,
                 acr_instance_id: Optional[builtins.str] = None,
                 commands: Optional[Sequence[builtins.str]] = None,
                 entrypoints: Optional[Sequence[builtins.str]] = None,
                 health_check_config: Optional['outputs.V3FunctionCustomContainerConfigHealthCheckConfig'] = None,
                 image: Optional[builtins.str] = None,
                 port: Optional[builtins.int] = None,
                 resolved_image_uri: Optional[builtins.str] = None):
        """
        :param 'V3FunctionCustomContainerConfigAccelerationInfoArgs' acceleration_info: (Deprecated since v1.242.0) Image Acceleration Information (Obsolete)
        :param builtins.str acceleration_type: Whether to enable Image acceleration. Default: The Default value, indicating that image acceleration is enabled. None: indicates that image acceleration is disabled. (Obsolete)
        :param builtins.str acr_instance_id: ACR Enterprise version Image Repository ID, which must be entered when using ACR Enterprise version image. (Obsolete)
        :param Sequence[builtins.str] commands: Container startup parameters.
        :param Sequence[builtins.str] entrypoints: Container start command.
        :param 'V3FunctionCustomContainerConfigHealthCheckConfigArgs' health_check_config: Function custom health check configuration See `health_check_config` below.
        :param builtins.str image: The container Image address.
        :param builtins.int port: The listening port of the HTTP Server when the custom container runs.
        :param builtins.str resolved_image_uri: The actual digest version of the deployed Image. The code version specified by this digest is used when the function starts.
        """
        if acceleration_info is not None:
            pulumi.set(__self__, "acceleration_info", acceleration_info)
        if acceleration_type is not None:
            pulumi.set(__self__, "acceleration_type", acceleration_type)
        if acr_instance_id is not None:
            pulumi.set(__self__, "acr_instance_id", acr_instance_id)
        if commands is not None:
            pulumi.set(__self__, "commands", commands)
        if entrypoints is not None:
            pulumi.set(__self__, "entrypoints", entrypoints)
        if health_check_config is not None:
            pulumi.set(__self__, "health_check_config", health_check_config)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if resolved_image_uri is not None:
            pulumi.set(__self__, "resolved_image_uri", resolved_image_uri)

    @property
    @pulumi.getter(name="accelerationInfo")
    @_utilities.deprecated("""Field 'acceleration_info' has been deprecated from provider version 1.228.0. Image Acceleration Information (Obsolete)""")
    def acceleration_info(self) -> Optional['outputs.V3FunctionCustomContainerConfigAccelerationInfo']:
        """
        (Deprecated since v1.242.0) Image Acceleration Information (Obsolete)
        """
        return pulumi.get(self, "acceleration_info")

    @property
    @pulumi.getter(name="accelerationType")
    @_utilities.deprecated("""Field 'acceleration_type' has been deprecated from provider version 1.228.0. Whether to enable Image acceleration. Default: The Default value, indicating that image acceleration is enabled. None: indicates that image acceleration is disabled. (Obsolete)""")
    def acceleration_type(self) -> Optional[builtins.str]:
        """
        Whether to enable Image acceleration. Default: The Default value, indicating that image acceleration is enabled. None: indicates that image acceleration is disabled. (Obsolete)
        """
        return pulumi.get(self, "acceleration_type")

    @property
    @pulumi.getter(name="acrInstanceId")
    @_utilities.deprecated("""Field 'acr_instance_id' has been deprecated from provider version 1.228.0. ACR Enterprise version Image Repository ID, which must be entered when using ACR Enterprise version image. (Obsolete)""")
    def acr_instance_id(self) -> Optional[builtins.str]:
        """
        ACR Enterprise version Image Repository ID, which must be entered when using ACR Enterprise version image. (Obsolete)
        """
        return pulumi.get(self, "acr_instance_id")

    @property
    @pulumi.getter
    def commands(self) -> Optional[Sequence[builtins.str]]:
        """
        Container startup parameters.
        """
        return pulumi.get(self, "commands")

    @property
    @pulumi.getter
    def entrypoints(self) -> Optional[Sequence[builtins.str]]:
        """
        Container start command.
        """
        return pulumi.get(self, "entrypoints")

    @property
    @pulumi.getter(name="healthCheckConfig")
    def health_check_config(self) -> Optional['outputs.V3FunctionCustomContainerConfigHealthCheckConfig']:
        """
        Function custom health check configuration See `health_check_config` below.
        """
        return pulumi.get(self, "health_check_config")

    @property
    @pulumi.getter
    def image(self) -> Optional[builtins.str]:
        """
        The container Image address.
        """
        return pulumi.get(self, "image")

    @property
    @pulumi.getter
    def port(self) -> Optional[builtins.int]:
        """
        The listening port of the HTTP Server when the custom container runs.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="resolvedImageUri")
    def resolved_image_uri(self) -> Optional[builtins.str]:
        """
        The actual digest version of the deployed Image. The code version specified by this digest is used when the function starts.
        """
        return pulumi.get(self, "resolved_image_uri")


@pulumi.output_type
class V3FunctionCustomContainerConfigAccelerationInfo(dict):
    def __init__(__self__, *,
                 status: Optional[builtins.str] = None):
        """
        :param builtins.str status: Image Acceleration Status (Deprecated)
        """
        if status is not None:
            pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter
    @_utilities.deprecated("""Field 'status' has been deprecated from provider version 1.228.0. Image Acceleration Status (Deprecated)""")
    def status(self) -> Optional[builtins.str]:
        """
        Image Acceleration Status (Deprecated)
        """
        return pulumi.get(self, "status")


@pulumi.output_type
class V3FunctionCustomContainerConfigHealthCheckConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "failureThreshold":
            suggest = "failure_threshold"
        elif key == "httpGetUrl":
            suggest = "http_get_url"
        elif key == "initialDelaySeconds":
            suggest = "initial_delay_seconds"
        elif key == "periodSeconds":
            suggest = "period_seconds"
        elif key == "successThreshold":
            suggest = "success_threshold"
        elif key == "timeoutSeconds":
            suggest = "timeout_seconds"

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

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

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

    def __init__(__self__, *,
                 failure_threshold: Optional[builtins.int] = None,
                 http_get_url: Optional[builtins.str] = None,
                 initial_delay_seconds: Optional[builtins.int] = None,
                 period_seconds: Optional[builtins.int] = None,
                 success_threshold: Optional[builtins.int] = None,
                 timeout_seconds: Optional[builtins.int] = None):
        if failure_threshold is not None:
            pulumi.set(__self__, "failure_threshold", failure_threshold)
        if http_get_url is not None:
            pulumi.set(__self__, "http_get_url", http_get_url)
        if initial_delay_seconds is not None:
            pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
        if period_seconds is not None:
            pulumi.set(__self__, "period_seconds", period_seconds)
        if success_threshold is not None:
            pulumi.set(__self__, "success_threshold", success_threshold)
        if timeout_seconds is not None:
            pulumi.set(__self__, "timeout_seconds", timeout_seconds)

    @property
    @pulumi.getter(name="failureThreshold")
    def failure_threshold(self) -> Optional[builtins.int]:
        return pulumi.get(self, "failure_threshold")

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

    @property
    @pulumi.getter(name="initialDelaySeconds")
    def initial_delay_seconds(self) -> Optional[builtins.int]:
        return pulumi.get(self, "initial_delay_seconds")

    @property
    @pulumi.getter(name="periodSeconds")
    def period_seconds(self) -> Optional[builtins.int]:
        return pulumi.get(self, "period_seconds")

    @property
    @pulumi.getter(name="successThreshold")
    def success_threshold(self) -> Optional[builtins.int]:
        return pulumi.get(self, "success_threshold")

    @property
    @pulumi.getter(name="timeoutSeconds")
    def timeout_seconds(self) -> Optional[builtins.int]:
        return pulumi.get(self, "timeout_seconds")


@pulumi.output_type
class V3FunctionCustomDns(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dnsOptions":
            suggest = "dns_options"
        elif key == "nameServers":
            suggest = "name_servers"

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

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

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

    def __init__(__self__, *,
                 dns_options: Optional[Sequence['outputs.V3FunctionCustomDnsDnsOption']] = None,
                 name_servers: Optional[Sequence[builtins.str]] = None,
                 searches: Optional[Sequence[builtins.str]] = None):
        """
        :param Sequence['V3FunctionCustomDnsDnsOptionArgs'] dns_options: List of configuration items in the resolv.conf file. Each item corresponds to a key-value pair in the format of key:value, where the key is required. See `dns_options` below.
        :param Sequence[builtins.str] name_servers: IP Address List of DNS servers
        :param Sequence[builtins.str] searches: DNS search domain list
        """
        if dns_options is not None:
            pulumi.set(__self__, "dns_options", dns_options)
        if name_servers is not None:
            pulumi.set(__self__, "name_servers", name_servers)
        if searches is not None:
            pulumi.set(__self__, "searches", searches)

    @property
    @pulumi.getter(name="dnsOptions")
    def dns_options(self) -> Optional[Sequence['outputs.V3FunctionCustomDnsDnsOption']]:
        """
        List of configuration items in the resolv.conf file. Each item corresponds to a key-value pair in the format of key:value, where the key is required. See `dns_options` below.
        """
        return pulumi.get(self, "dns_options")

    @property
    @pulumi.getter(name="nameServers")
    def name_servers(self) -> Optional[Sequence[builtins.str]]:
        """
        IP Address List of DNS servers
        """
        return pulumi.get(self, "name_servers")

    @property
    @pulumi.getter
    def searches(self) -> Optional[Sequence[builtins.str]]:
        """
        DNS search domain list
        """
        return pulumi.get(self, "searches")


@pulumi.output_type
class V3FunctionCustomDnsDnsOption(dict):
    def __init__(__self__, *,
                 name: Optional[builtins.str] = None,
                 value: Optional[builtins.str] = None):
        """
        :param builtins.str name: Configuration Item Name
        :param builtins.str value: Configuration Item Value
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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


@pulumi.output_type
class V3FunctionCustomRuntimeConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "healthCheckConfig":
            suggest = "health_check_config"

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

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

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

    def __init__(__self__, *,
                 args: Optional[Sequence[builtins.str]] = None,
                 commands: Optional[Sequence[builtins.str]] = None,
                 health_check_config: Optional['outputs.V3FunctionCustomRuntimeConfigHealthCheckConfig'] = None,
                 port: Optional[builtins.int] = None):
        """
        :param Sequence[builtins.str] args: Instance startup parameters.
        :param Sequence[builtins.str] commands: Instance start command.
        :param 'V3FunctionCustomRuntimeConfigHealthCheckConfigArgs' health_check_config: Function custom health check configuration. See `health_check_config` below.
        :param builtins.int port: The listening port of the HTTP Server.
        """
        if args is not None:
            pulumi.set(__self__, "args", args)
        if commands is not None:
            pulumi.set(__self__, "commands", commands)
        if health_check_config is not None:
            pulumi.set(__self__, "health_check_config", health_check_config)
        if port is not None:
            pulumi.set(__self__, "port", port)

    @property
    @pulumi.getter
    def args(self) -> Optional[Sequence[builtins.str]]:
        """
        Instance startup parameters.
        """
        return pulumi.get(self, "args")

    @property
    @pulumi.getter
    def commands(self) -> Optional[Sequence[builtins.str]]:
        """
        Instance start command.
        """
        return pulumi.get(self, "commands")

    @property
    @pulumi.getter(name="healthCheckConfig")
    def health_check_config(self) -> Optional['outputs.V3FunctionCustomRuntimeConfigHealthCheckConfig']:
        """
        Function custom health check configuration. See `health_check_config` below.
        """
        return pulumi.get(self, "health_check_config")

    @property
    @pulumi.getter
    def port(self) -> Optional[builtins.int]:
        """
        The listening port of the HTTP Server.
        """
        return pulumi.get(self, "port")


@pulumi.output_type
class V3FunctionCustomRuntimeConfigHealthCheckConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "failureThreshold":
            suggest = "failure_threshold"
        elif key == "httpGetUrl":
            suggest = "http_get_url"
        elif key == "initialDelaySeconds":
            suggest = "initial_delay_seconds"
        elif key == "periodSeconds":
            suggest = "period_seconds"
        elif key == "successThreshold":
            suggest = "success_threshold"
        elif key == "timeoutSeconds":
            suggest = "timeout_seconds"

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

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

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

    def __init__(__self__, *,
                 failure_threshold: Optional[builtins.int] = None,
                 http_get_url: Optional[builtins.str] = None,
                 initial_delay_seconds: Optional[builtins.int] = None,
                 period_seconds: Optional[builtins.int] = None,
                 success_threshold: Optional[builtins.int] = None,
                 timeout_seconds: Optional[builtins.int] = None):
        if failure_threshold is not None:
            pulumi.set(__self__, "failure_threshold", failure_threshold)
        if http_get_url is not None:
            pulumi.set(__self__, "http_get_url", http_get_url)
        if initial_delay_seconds is not None:
            pulumi.set(__self__, "initial_delay_seconds", initial_delay_seconds)
        if period_seconds is not None:
            pulumi.set(__self__, "period_seconds", period_seconds)
        if success_threshold is not None:
            pulumi.set(__self__, "success_threshold", success_threshold)
        if timeout_seconds is not None:
            pulumi.set(__self__, "timeout_seconds", timeout_seconds)

    @property
    @pulumi.getter(name="failureThreshold")
    def failure_threshold(self) -> Optional[builtins.int]:
        return pulumi.get(self, "failure_threshold")

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

    @property
    @pulumi.getter(name="initialDelaySeconds")
    def initial_delay_seconds(self) -> Optional[builtins.int]:
        return pulumi.get(self, "initial_delay_seconds")

    @property
    @pulumi.getter(name="periodSeconds")
    def period_seconds(self) -> Optional[builtins.int]:
        return pulumi.get(self, "period_seconds")

    @property
    @pulumi.getter(name="successThreshold")
    def success_threshold(self) -> Optional[builtins.int]:
        return pulumi.get(self, "success_threshold")

    @property
    @pulumi.getter(name="timeoutSeconds")
    def timeout_seconds(self) -> Optional[builtins.int]:
        return pulumi.get(self, "timeout_seconds")


@pulumi.output_type
class V3FunctionGpuConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "gpuMemorySize":
            suggest = "gpu_memory_size"
        elif key == "gpuType":
            suggest = "gpu_type"

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

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

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

    def __init__(__self__, *,
                 gpu_memory_size: Optional[builtins.int] = None,
                 gpu_type: Optional[builtins.str] = None):
        """
        :param builtins.int gpu_memory_size: GPU memory specification, unit: MB, multiple of 1024MB
        :param builtins.str gpu_type: GPU card architecture.
               - fc.gpu.tesla.1 indicates the type of the Tesla Architecture Series card of the GPU instance (the same as the NVIDIA T4 card type).
               - fc.gpu.ampere.1 indicates the GPU instance type of Ampere Architecture Series card (same as NVIDIA A10 card type).
               - fc.gpu.ada.1 Indicates the GPU instance Ada Lovelace architecture family card type.
        """
        if gpu_memory_size is not None:
            pulumi.set(__self__, "gpu_memory_size", gpu_memory_size)
        if gpu_type is not None:
            pulumi.set(__self__, "gpu_type", gpu_type)

    @property
    @pulumi.getter(name="gpuMemorySize")
    def gpu_memory_size(self) -> Optional[builtins.int]:
        """
        GPU memory specification, unit: MB, multiple of 1024MB
        """
        return pulumi.get(self, "gpu_memory_size")

    @property
    @pulumi.getter(name="gpuType")
    def gpu_type(self) -> Optional[builtins.str]:
        """
        GPU card architecture.
        - fc.gpu.tesla.1 indicates the type of the Tesla Architecture Series card of the GPU instance (the same as the NVIDIA T4 card type).
        - fc.gpu.ampere.1 indicates the GPU instance type of Ampere Architecture Series card (same as NVIDIA A10 card type).
        - fc.gpu.ada.1 Indicates the GPU instance Ada Lovelace architecture family card type.
        """
        return pulumi.get(self, "gpu_type")


@pulumi.output_type
class V3FunctionInstanceLifecycleConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "preStop":
            suggest = "pre_stop"

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

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

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

    def __init__(__self__, *,
                 initializer: Optional['outputs.V3FunctionInstanceLifecycleConfigInitializer'] = None,
                 pre_stop: Optional['outputs.V3FunctionInstanceLifecycleConfigPreStop'] = None):
        """
        :param 'V3FunctionInstanceLifecycleConfigInitializerArgs' initializer: Initializer handler method configuration See `initializer` below.
        :param 'V3FunctionInstanceLifecycleConfigPreStopArgs' pre_stop: PreStop handler method configuration See `pre_stop` below.
        """
        if initializer is not None:
            pulumi.set(__self__, "initializer", initializer)
        if pre_stop is not None:
            pulumi.set(__self__, "pre_stop", pre_stop)

    @property
    @pulumi.getter
    def initializer(self) -> Optional['outputs.V3FunctionInstanceLifecycleConfigInitializer']:
        """
        Initializer handler method configuration See `initializer` below.
        """
        return pulumi.get(self, "initializer")

    @property
    @pulumi.getter(name="preStop")
    def pre_stop(self) -> Optional['outputs.V3FunctionInstanceLifecycleConfigPreStop']:
        """
        PreStop handler method configuration See `pre_stop` below.
        """
        return pulumi.get(self, "pre_stop")


@pulumi.output_type
class V3FunctionInstanceLifecycleConfigInitializer(dict):
    def __init__(__self__, *,
                 handler: Optional[builtins.str] = None,
                 timeout: Optional[builtins.int] = None):
        """
        :param builtins.str handler: Function Handler: the call entry for the function compute system to run your function.
        :param builtins.int timeout: The maximum running time of the function, in seconds.
        """
        if handler is not None:
            pulumi.set(__self__, "handler", handler)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter
    def handler(self) -> Optional[builtins.str]:
        """
        Function Handler: the call entry for the function compute system to run your function.
        """
        return pulumi.get(self, "handler")

    @property
    @pulumi.getter
    def timeout(self) -> Optional[builtins.int]:
        """
        The maximum running time of the function, in seconds.
        """
        return pulumi.get(self, "timeout")


@pulumi.output_type
class V3FunctionInstanceLifecycleConfigPreStop(dict):
    def __init__(__self__, *,
                 handler: Optional[builtins.str] = None,
                 timeout: Optional[builtins.int] = None):
        """
        :param builtins.str handler: Function Handler: the call entry for the function compute system to run your function.
        :param builtins.int timeout: The maximum running time of the function, in seconds.
        """
        if handler is not None:
            pulumi.set(__self__, "handler", handler)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter
    def handler(self) -> Optional[builtins.str]:
        """
        Function Handler: the call entry for the function compute system to run your function.
        """
        return pulumi.get(self, "handler")

    @property
    @pulumi.getter
    def timeout(self) -> Optional[builtins.int]:
        """
        The maximum running time of the function, in seconds.
        """
        return pulumi.get(self, "timeout")


@pulumi.output_type
class V3FunctionLogConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enableInstanceMetrics":
            suggest = "enable_instance_metrics"
        elif key == "enableRequestMetrics":
            suggest = "enable_request_metrics"
        elif key == "logBeginRule":
            suggest = "log_begin_rule"

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

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

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

    def __init__(__self__, *,
                 enable_instance_metrics: Optional[builtins.bool] = None,
                 enable_request_metrics: Optional[builtins.bool] = None,
                 log_begin_rule: Optional[builtins.str] = None,
                 logstore: Optional[builtins.str] = None,
                 project: Optional[builtins.str] = None):
        """
        :param builtins.bool enable_instance_metrics: After this feature is enabled, you can view core metrics such as instance-level CPU usage, memory usage, instance network status, and the number of requests within an instance. false: The default value, which means that instance-level metrics are turned off. true: indicates that instance-level metrics are enabled.
        :param builtins.bool enable_request_metrics: After this function is enabled, you can view the time and memory consumed by a call to all functions under this service. false: indicates that request-level metrics are turned off. true: The default value, indicating that request-level metrics are enabled.
        :param builtins.str log_begin_rule: Log Line First Matching Rules
        :param builtins.str logstore: The Logstore name of log service.
        :param builtins.str project: The name of the log service Project.
        """
        if enable_instance_metrics is not None:
            pulumi.set(__self__, "enable_instance_metrics", enable_instance_metrics)
        if enable_request_metrics is not None:
            pulumi.set(__self__, "enable_request_metrics", enable_request_metrics)
        if log_begin_rule is not None:
            pulumi.set(__self__, "log_begin_rule", log_begin_rule)
        if logstore is not None:
            pulumi.set(__self__, "logstore", logstore)
        if project is not None:
            pulumi.set(__self__, "project", project)

    @property
    @pulumi.getter(name="enableInstanceMetrics")
    def enable_instance_metrics(self) -> Optional[builtins.bool]:
        """
        After this feature is enabled, you can view core metrics such as instance-level CPU usage, memory usage, instance network status, and the number of requests within an instance. false: The default value, which means that instance-level metrics are turned off. true: indicates that instance-level metrics are enabled.
        """
        return pulumi.get(self, "enable_instance_metrics")

    @property
    @pulumi.getter(name="enableRequestMetrics")
    def enable_request_metrics(self) -> Optional[builtins.bool]:
        """
        After this function is enabled, you can view the time and memory consumed by a call to all functions under this service. false: indicates that request-level metrics are turned off. true: The default value, indicating that request-level metrics are enabled.
        """
        return pulumi.get(self, "enable_request_metrics")

    @property
    @pulumi.getter(name="logBeginRule")
    def log_begin_rule(self) -> Optional[builtins.str]:
        """
        Log Line First Matching Rules
        """
        return pulumi.get(self, "log_begin_rule")

    @property
    @pulumi.getter
    def logstore(self) -> Optional[builtins.str]:
        """
        The Logstore name of log service.
        """
        return pulumi.get(self, "logstore")

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


@pulumi.output_type
class V3FunctionNasConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "groupId":
            suggest = "group_id"
        elif key == "mountPoints":
            suggest = "mount_points"
        elif key == "userId":
            suggest = "user_id"

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

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

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

    def __init__(__self__, *,
                 group_id: Optional[builtins.int] = None,
                 mount_points: Optional[Sequence['outputs.V3FunctionNasConfigMountPoint']] = None,
                 user_id: Optional[builtins.int] = None):
        """
        :param builtins.int group_id: Group ID
        :param Sequence['V3FunctionNasConfigMountPointArgs'] mount_points: Mount point list See `mount_points` below.
        :param builtins.int user_id: Account ID
        """
        if group_id is not None:
            pulumi.set(__self__, "group_id", group_id)
        if mount_points is not None:
            pulumi.set(__self__, "mount_points", mount_points)
        if user_id is not None:
            pulumi.set(__self__, "user_id", user_id)

    @property
    @pulumi.getter(name="groupId")
    def group_id(self) -> Optional[builtins.int]:
        """
        Group ID
        """
        return pulumi.get(self, "group_id")

    @property
    @pulumi.getter(name="mountPoints")
    def mount_points(self) -> Optional[Sequence['outputs.V3FunctionNasConfigMountPoint']]:
        """
        Mount point list See `mount_points` below.
        """
        return pulumi.get(self, "mount_points")

    @property
    @pulumi.getter(name="userId")
    def user_id(self) -> Optional[builtins.int]:
        """
        Account ID
        """
        return pulumi.get(self, "user_id")


@pulumi.output_type
class V3FunctionNasConfigMountPoint(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enableTls":
            suggest = "enable_tls"
        elif key == "mountDir":
            suggest = "mount_dir"
        elif key == "serverAddr":
            suggest = "server_addr"

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

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

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

    def __init__(__self__, *,
                 enable_tls: Optional[builtins.bool] = None,
                 mount_dir: Optional[builtins.str] = None,
                 server_addr: Optional[builtins.str] = None):
        """
        :param builtins.bool enable_tls: Use transport encryption to mount. Note: only general-purpose NAS supports transmission encryption.
        :param builtins.str server_addr: NAS server address
        """
        if enable_tls is not None:
            pulumi.set(__self__, "enable_tls", enable_tls)
        if mount_dir is not None:
            pulumi.set(__self__, "mount_dir", mount_dir)
        if server_addr is not None:
            pulumi.set(__self__, "server_addr", server_addr)

    @property
    @pulumi.getter(name="enableTls")
    def enable_tls(self) -> Optional[builtins.bool]:
        """
        Use transport encryption to mount. Note: only general-purpose NAS supports transmission encryption.
        """
        return pulumi.get(self, "enable_tls")

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

    @property
    @pulumi.getter(name="serverAddr")
    def server_addr(self) -> Optional[builtins.str]:
        """
        NAS server address
        """
        return pulumi.get(self, "server_addr")


@pulumi.output_type
class V3FunctionOssMountConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "mountPoints":
            suggest = "mount_points"

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

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

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

    def __init__(__self__, *,
                 mount_points: Optional[Sequence['outputs.V3FunctionOssMountConfigMountPoint']] = None):
        """
        :param Sequence['V3FunctionOssMountConfigMountPointArgs'] mount_points: OSS mount point list See `mount_points` below.
        """
        if mount_points is not None:
            pulumi.set(__self__, "mount_points", mount_points)

    @property
    @pulumi.getter(name="mountPoints")
    def mount_points(self) -> Optional[Sequence['outputs.V3FunctionOssMountConfigMountPoint']]:
        """
        OSS mount point list See `mount_points` below.
        """
        return pulumi.get(self, "mount_points")


@pulumi.output_type
class V3FunctionOssMountConfigMountPoint(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bucketName":
            suggest = "bucket_name"
        elif key == "bucketPath":
            suggest = "bucket_path"
        elif key == "mountDir":
            suggest = "mount_dir"
        elif key == "readOnly":
            suggest = "read_only"

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

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

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

    def __init__(__self__, *,
                 bucket_name: Optional[builtins.str] = None,
                 bucket_path: Optional[builtins.str] = None,
                 endpoint: Optional[builtins.str] = None,
                 mount_dir: Optional[builtins.str] = None,
                 read_only: Optional[builtins.bool] = None):
        """
        :param builtins.str bucket_name: OSS Bucket name
        :param builtins.str bucket_path: Path of the mounted OSS Bucket
        :param builtins.str endpoint: OSS access endpoint
        :param builtins.bool read_only: Read-only
        """
        if bucket_name is not None:
            pulumi.set(__self__, "bucket_name", bucket_name)
        if bucket_path is not None:
            pulumi.set(__self__, "bucket_path", bucket_path)
        if endpoint is not None:
            pulumi.set(__self__, "endpoint", endpoint)
        if mount_dir is not None:
            pulumi.set(__self__, "mount_dir", mount_dir)
        if read_only is not None:
            pulumi.set(__self__, "read_only", read_only)

    @property
    @pulumi.getter(name="bucketName")
    def bucket_name(self) -> Optional[builtins.str]:
        """
        OSS Bucket name
        """
        return pulumi.get(self, "bucket_name")

    @property
    @pulumi.getter(name="bucketPath")
    def bucket_path(self) -> Optional[builtins.str]:
        """
        Path of the mounted OSS Bucket
        """
        return pulumi.get(self, "bucket_path")

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

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

    @property
    @pulumi.getter(name="readOnly")
    def read_only(self) -> Optional[builtins.bool]:
        """
        Read-only
        """
        return pulumi.get(self, "read_only")


@pulumi.output_type
class V3FunctionTracingConfig(dict):
    def __init__(__self__, *,
                 params: Optional[Mapping[str, builtins.str]] = None,
                 type: Optional[builtins.str] = None):
        """
        :param Mapping[str, builtins.str] params: Tracing parameters.
        :param builtins.str type: The tracing protocol type. Currently, only Jaeger is supported.
        """
        if params is not None:
            pulumi.set(__self__, "params", params)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def params(self) -> Optional[Mapping[str, builtins.str]]:
        """
        Tracing parameters.
        """
        return pulumi.get(self, "params")

    @property
    @pulumi.getter
    def type(self) -> Optional[builtins.str]:
        """
        The tracing protocol type. Currently, only Jaeger is supported.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class V3FunctionVpcConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "securityGroupId":
            suggest = "security_group_id"
        elif key == "vpcId":
            suggest = "vpc_id"
        elif key == "vswitchIds":
            suggest = "vswitch_ids"

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

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

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

    def __init__(__self__, *,
                 security_group_id: Optional[builtins.str] = None,
                 vpc_id: Optional[builtins.str] = None,
                 vswitch_ids: Optional[Sequence[builtins.str]] = None):
        """
        :param builtins.str security_group_id: Security group ID
        :param builtins.str vpc_id: VPC network ID
        :param Sequence[builtins.str] vswitch_ids: Switch List
        """
        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 vswitch_ids is not None:
            pulumi.set(__self__, "vswitch_ids", vswitch_ids)

    @property
    @pulumi.getter(name="securityGroupId")
    def security_group_id(self) -> Optional[builtins.str]:
        """
        Security group ID
        """
        return pulumi.get(self, "security_group_id")

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

    @property
    @pulumi.getter(name="vswitchIds")
    def vswitch_ids(self) -> Optional[Sequence[builtins.str]]:
        """
        Switch List
        """
        return pulumi.get(self, "vswitch_ids")


@pulumi.output_type
class V3LayerVersionCode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ossBucketName":
            suggest = "oss_bucket_name"
        elif key == "ossObjectName":
            suggest = "oss_object_name"
        elif key == "zipFile":
            suggest = "zip_file"

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

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

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

    def __init__(__self__, *,
                 checksum: Optional[builtins.str] = None,
                 oss_bucket_name: Optional[builtins.str] = None,
                 oss_object_name: Optional[builtins.str] = None,
                 zip_file: Optional[builtins.str] = None):
        """
        :param builtins.str checksum: The CRC-64 value of the code package. If checksum is provided, Function Compute checks whether the checksum of the code package is consistent with the provided checksum.
        :param builtins.str oss_bucket_name: Name of the OSS Bucket where the user stores the Layer Code ZIP package
        :param builtins.str oss_object_name: Name of the OSS Object where the user stores the Layer Code ZIP package
        :param builtins.str zip_file: Base 64 encoding of Layer Code ZIP package
        """
        if checksum is not None:
            pulumi.set(__self__, "checksum", checksum)
        if oss_bucket_name is not None:
            pulumi.set(__self__, "oss_bucket_name", oss_bucket_name)
        if oss_object_name is not None:
            pulumi.set(__self__, "oss_object_name", oss_object_name)
        if zip_file is not None:
            pulumi.set(__self__, "zip_file", zip_file)

    @property
    @pulumi.getter
    def checksum(self) -> Optional[builtins.str]:
        """
        The CRC-64 value of the code package. If checksum is provided, Function Compute checks whether the checksum of the code package is consistent with the provided checksum.
        """
        return pulumi.get(self, "checksum")

    @property
    @pulumi.getter(name="ossBucketName")
    def oss_bucket_name(self) -> Optional[builtins.str]:
        """
        Name of the OSS Bucket where the user stores the Layer Code ZIP package
        """
        return pulumi.get(self, "oss_bucket_name")

    @property
    @pulumi.getter(name="ossObjectName")
    def oss_object_name(self) -> Optional[builtins.str]:
        """
        Name of the OSS Object where the user stores the Layer Code ZIP package
        """
        return pulumi.get(self, "oss_object_name")

    @property
    @pulumi.getter(name="zipFile")
    def zip_file(self) -> Optional[builtins.str]:
        """
        Base 64 encoding of Layer Code ZIP package
        """
        return pulumi.get(self, "zip_file")


@pulumi.output_type
class V3ProvisionConfigScheduledAction(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "endTime":
            suggest = "end_time"
        elif key == "scheduleExpression":
            suggest = "schedule_expression"
        elif key == "startTime":
            suggest = "start_time"
        elif key == "timeZone":
            suggest = "time_zone"

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

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

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

    def __init__(__self__, *,
                 end_time: Optional[builtins.str] = None,
                 name: Optional[builtins.str] = None,
                 schedule_expression: Optional[builtins.str] = None,
                 start_time: Optional[builtins.str] = None,
                 target: Optional[builtins.int] = None,
                 time_zone: Optional[builtins.str] = None):
        """
        :param builtins.str end_time: Policy expiration time
        :param builtins.str name: Policy Name
        :param builtins.str schedule_expression: Timing Configuration
        :param builtins.str start_time: Policy effective time
        :param builtins.int target: Number of reserved target resources
        :param builtins.str time_zone: Time zone.
        """
        if end_time is not None:
            pulumi.set(__self__, "end_time", end_time)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if schedule_expression is not None:
            pulumi.set(__self__, "schedule_expression", schedule_expression)
        if start_time is not None:
            pulumi.set(__self__, "start_time", start_time)
        if target is not None:
            pulumi.set(__self__, "target", target)
        if time_zone is not None:
            pulumi.set(__self__, "time_zone", time_zone)

    @property
    @pulumi.getter(name="endTime")
    def end_time(self) -> Optional[builtins.str]:
        """
        Policy expiration time
        """
        return pulumi.get(self, "end_time")

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

    @property
    @pulumi.getter(name="scheduleExpression")
    def schedule_expression(self) -> Optional[builtins.str]:
        """
        Timing Configuration
        """
        return pulumi.get(self, "schedule_expression")

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> Optional[builtins.str]:
        """
        Policy effective time
        """
        return pulumi.get(self, "start_time")

    @property
    @pulumi.getter
    def target(self) -> Optional[builtins.int]:
        """
        Number of reserved target resources
        """
        return pulumi.get(self, "target")

    @property
    @pulumi.getter(name="timeZone")
    def time_zone(self) -> Optional[builtins.str]:
        """
        Time zone.
        """
        return pulumi.get(self, "time_zone")


@pulumi.output_type
class V3ProvisionConfigTargetTrackingPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "endTime":
            suggest = "end_time"
        elif key == "maxCapacity":
            suggest = "max_capacity"
        elif key == "metricTarget":
            suggest = "metric_target"
        elif key == "metricType":
            suggest = "metric_type"
        elif key == "minCapacity":
            suggest = "min_capacity"
        elif key == "startTime":
            suggest = "start_time"
        elif key == "timeZone":
            suggest = "time_zone"

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

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

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

    def __init__(__self__, *,
                 end_time: Optional[builtins.str] = None,
                 max_capacity: Optional[builtins.int] = None,
                 metric_target: Optional[builtins.float] = None,
                 metric_type: Optional[builtins.str] = None,
                 min_capacity: Optional[builtins.int] = None,
                 name: Optional[builtins.str] = None,
                 start_time: Optional[builtins.str] = None,
                 time_zone: Optional[builtins.str] = None):
        """
        :param builtins.str end_time: Policy expiration time
        :param builtins.int max_capacity: Maximum value of expansion
        :param builtins.float metric_target: Tracking value of the indicator
        :param builtins.str metric_type: Provisionedconcurrency utilization: Concurrency utilization of reserved mode instances. CPU utilization: CPU utilization. GPUMemUtilization:GPU utilization
        :param builtins.int min_capacity: Minimum Shrinkage
        :param builtins.str name: Policy Name
        :param builtins.str start_time: Policy Effective Time
        :param builtins.str time_zone: Time zone.
        """
        if end_time is not None:
            pulumi.set(__self__, "end_time", end_time)
        if max_capacity is not None:
            pulumi.set(__self__, "max_capacity", max_capacity)
        if metric_target is not None:
            pulumi.set(__self__, "metric_target", metric_target)
        if metric_type is not None:
            pulumi.set(__self__, "metric_type", metric_type)
        if min_capacity is not None:
            pulumi.set(__self__, "min_capacity", min_capacity)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if start_time is not None:
            pulumi.set(__self__, "start_time", start_time)
        if time_zone is not None:
            pulumi.set(__self__, "time_zone", time_zone)

    @property
    @pulumi.getter(name="endTime")
    def end_time(self) -> Optional[builtins.str]:
        """
        Policy expiration time
        """
        return pulumi.get(self, "end_time")

    @property
    @pulumi.getter(name="maxCapacity")
    def max_capacity(self) -> Optional[builtins.int]:
        """
        Maximum value of expansion
        """
        return pulumi.get(self, "max_capacity")

    @property
    @pulumi.getter(name="metricTarget")
    def metric_target(self) -> Optional[builtins.float]:
        """
        Tracking value of the indicator
        """
        return pulumi.get(self, "metric_target")

    @property
    @pulumi.getter(name="metricType")
    def metric_type(self) -> Optional[builtins.str]:
        """
        Provisionedconcurrency utilization: Concurrency utilization of reserved mode instances. CPU utilization: CPU utilization. GPUMemUtilization:GPU utilization
        """
        return pulumi.get(self, "metric_type")

    @property
    @pulumi.getter(name="minCapacity")
    def min_capacity(self) -> Optional[builtins.int]:
        """
        Minimum Shrinkage
        """
        return pulumi.get(self, "min_capacity")

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

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> Optional[builtins.str]:
        """
        Policy Effective Time
        """
        return pulumi.get(self, "start_time")

    @property
    @pulumi.getter(name="timeZone")
    def time_zone(self) -> Optional[builtins.str]:
        """
        Time zone.
        """
        return pulumi.get(self, "time_zone")


@pulumi.output_type
class V3TriggerHttpTrigger(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "urlInternet":
            suggest = "url_internet"
        elif key == "urlIntranet":
            suggest = "url_intranet"

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

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

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

    def __init__(__self__, *,
                 url_internet: Optional[builtins.str] = None,
                 url_intranet: Optional[builtins.str] = None):
        """
        :param builtins.str url_internet: The public domain name address. On the Internet, you can access the HTTP Trigger through the HTTP protocol or HTTPS protocol.
        :param builtins.str url_intranet: The private domain name address. In a VPC, you can access the HTTP Trigger through HTTP or HTTPS.
        """
        if url_internet is not None:
            pulumi.set(__self__, "url_internet", url_internet)
        if url_intranet is not None:
            pulumi.set(__self__, "url_intranet", url_intranet)

    @property
    @pulumi.getter(name="urlInternet")
    def url_internet(self) -> Optional[builtins.str]:
        """
        The public domain name address. On the Internet, you can access the HTTP Trigger through the HTTP protocol or HTTPS protocol.
        """
        return pulumi.get(self, "url_internet")

    @property
    @pulumi.getter(name="urlIntranet")
    def url_intranet(self) -> Optional[builtins.str]:
        """
        The private domain name address. In a VPC, you can access the HTTP Trigger through HTTP or HTTPS.
        """
        return pulumi.get(self, "url_intranet")


@pulumi.output_type
class GetCustomDomainsDomainResult(dict):
    def __init__(__self__, *,
                 account_id: builtins.str,
                 api_version: builtins.str,
                 cert_config: 'outputs.GetCustomDomainsDomainCertConfigResult',
                 created_time: builtins.str,
                 domain_name: builtins.str,
                 id: builtins.str,
                 last_modified_time: builtins.str,
                 protocol: builtins.str,
                 route_configs: Sequence['outputs.GetCustomDomainsDomainRouteConfigResult']):
        """
        :param builtins.str account_id: The account id.
        :param builtins.str api_version: The API version of the Function Compute service.
        :param 'GetCustomDomainsDomainCertConfigArgs' cert_config: The configuration of HTTPS certificate.
        :param builtins.str created_time: The created time of the custom domain.
        :param builtins.str domain_name: The custom domain name.
        :param builtins.str id: The custom domain id, same as domain name.
        :param builtins.str last_modified_time: The last modified time of the custom domain.
        :param builtins.str protocol: The custom domain protocol.
        :param Sequence['GetCustomDomainsDomainRouteConfigArgs'] route_configs: The configuration of domain route, mapping the path and Function Compute function.
        """
        pulumi.set(__self__, "account_id", account_id)
        pulumi.set(__self__, "api_version", api_version)
        pulumi.set(__self__, "cert_config", cert_config)
        pulumi.set(__self__, "created_time", created_time)
        pulumi.set(__self__, "domain_name", domain_name)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "last_modified_time", last_modified_time)
        pulumi.set(__self__, "protocol", protocol)
        pulumi.set(__self__, "route_configs", route_configs)

    @property
    @pulumi.getter(name="accountId")
    def account_id(self) -> builtins.str:
        """
        The account id.
        """
        return pulumi.get(self, "account_id")

    @property
    @pulumi.getter(name="apiVersion")
    def api_version(self) -> builtins.str:
        """
        The API version of the Function Compute service.
        """
        return pulumi.get(self, "api_version")

    @property
    @pulumi.getter(name="certConfig")
    def cert_config(self) -> 'outputs.GetCustomDomainsDomainCertConfigResult':
        """
        The configuration of HTTPS certificate.
        """
        return pulumi.get(self, "cert_config")

    @property
    @pulumi.getter(name="createdTime")
    def created_time(self) -> builtins.str:
        """
        The created time of the custom domain.
        """
        return pulumi.get(self, "created_time")

    @property
    @pulumi.getter(name="domainName")
    def domain_name(self) -> builtins.str:
        """
        The custom domain name.
        """
        return pulumi.get(self, "domain_name")

    @property
    @pulumi.getter
    def id(self) -> builtins.str:
        """
        The custom domain id, same as domain name.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="lastModifiedTime")
    def last_modified_time(self) -> builtins.str:
        """
        The last modified time of the custom domain.
        """
        return pulumi.get(self, "last_modified_time")

    @property
    @pulumi.getter
    def protocol(self) -> builtins.str:
        """
        The custom domain protocol.
        """
        return pulumi.get(self, "protocol")

    @property
    @pulumi.getter(name="routeConfigs")
    def route_configs(self) -> Sequence['outputs.GetCustomDomainsDomainRouteConfigResult']:
        """
        The configuration of domain route, mapping the path and Function Compute function.
        """
        return pulumi.get(self, "route_configs")


@pulumi.output_type
class GetCustomDomainsDomainCertConfigResult(dict):
    def __init__(__self__, *,
                 cert_name: builtins.str,
                 certificate: builtins.str):
        """
        :param builtins.str cert_name: The name of the certificate.
        :param builtins.str certificate: Certificate data of the HTTPS certificates, follow the 'pem'.
        """
        pulumi.set(__self__, "cert_name", cert_name)
        pulumi.set(__self__, "certificate", certificate)

    @property
    @pulumi.getter(name="certName")
    def cert_name(self) -> builtins.str:
        """
        The name of the certificate.
        """
        return pulumi.get(self, "cert_name")

    @property
    @pulumi.getter
    def certificate(self) -> builtins.str:
        """
        Certificate data of the HTTPS certificates, follow the 'pem'.
        """
        return pulumi.get(self, "certificate")


@pulumi.output_type
class GetCustomDomainsDomainRouteConfigResult(dict):
    def __init__(__self__, *,
                 function_name: builtins.str,
                 methods: Sequence[builtins.str],
                 path: builtins.str,
                 qualifier: builtins.str,
                 service_name: builtins.str):
        """
        :param builtins.str function_name: The name of the Function Compute function that requests are routed to.
        :param Sequence[builtins.str] methods: The requests of the specified HTTP methos are routed from. Valid method: GET, POST, DELETE, HEAD, PUT and PATCH. For example, "GET, HEAD" methods indicate that only requests from GET and HEAD methods are routed.
        :param builtins.str path: The path that requests are routed from.
        :param builtins.str qualifier: The version or alias of the Function Compute service that requests are routed to. For example, qualifier v1 indicates that the requests are routed to the version 1 Function Compute service.
        :param builtins.str service_name: The name of the Function Compute service that requests are routed to.
        """
        pulumi.set(__self__, "function_name", function_name)
        pulumi.set(__self__, "methods", methods)
        pulumi.set(__self__, "path", path)
        pulumi.set(__self__, "qualifier", qualifier)
        pulumi.set(__self__, "service_name", service_name)

    @property
    @pulumi.getter(name="functionName")
    def function_name(self) -> builtins.str:
        """
        The name of the Function Compute function that requests are routed to.
        """
        return pulumi.get(self, "function_name")

    @property
    @pulumi.getter
    def methods(self) -> Sequence[builtins.str]:
        """
        The requests of the specified HTTP methos are routed from. Valid method: GET, POST, DELETE, HEAD, PUT and PATCH. For example, "GET, HEAD" methods indicate that only requests from GET and HEAD methods are routed.
        """
        return pulumi.get(self, "methods")

    @property
    @pulumi.getter
    def path(self) -> builtins.str:
        """
        The path that requests are routed from.
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def qualifier(self) -> builtins.str:
        """
        The version or alias of the Function Compute service that requests are routed to. For example, qualifier v1 indicates that the requests are routed to the version 1 Function Compute service.
        """
        return pulumi.get(self, "qualifier")

    @property
    @pulumi.getter(name="serviceName")
    def service_name(self) -> builtins.str:
        """
        The name of the Function Compute service that requests are routed to.
        """
        return pulumi.get(self, "service_name")


@pulumi.output_type
class GetFunctionsFunctionResult(dict):
    def __init__(__self__, *,
                 ca_port: builtins.int,
                 code_checksum: builtins.str,
                 code_size: builtins.int,
                 creation_time: builtins.str,
                 description: builtins.str,
                 environment_variables: Mapping[str, builtins.str],
                 handler: builtins.str,
                 id: builtins.str,
                 initialization_timeout: builtins.int,
                 initializer: builtins.str,
                 instance_concurrency: builtins.int,
                 instance_type: builtins.str,
                 last_modification_time: builtins.str,
                 memory_size: builtins.int,
                 name: builtins.str,
                 runtime: builtins.str,
                 timeout: builtins.int,
                 custom_container_config: Optional['outputs.GetFunctionsFunctionCustomContainerConfigResult'] = None):
        """
        :param builtins.int ca_port: The port that the function listen to, only valid for [custom runtime](https://www.alibabacloud.com/help/doc-detail/132044.htm) and [custom container runtime](https://www.alibabacloud.com/help/doc-detail/179368.htm).
        :param builtins.str code_checksum: Checksum (crc64) of the function code.
        :param builtins.int code_size: Function code size in bytes.
        :param builtins.str creation_time: Function creation time.
        :param builtins.str description: Function description.
        :param Mapping[str, builtins.str] environment_variables: A map that defines environment variables for the function.
        :param builtins.str handler: Function [entry point](https://www.alibabacloud.com/help/doc-detail/62213.htm) in the code.
        :param builtins.str id: Function ID.
        :param builtins.int initialization_timeout: The maximum length of time, in seconds, that the function's initialization should be run for.
        :param builtins.str initializer: The entry point of the function's [initialization](https://www.alibabacloud.com/help/doc-detail/157704.htm).
        :param builtins.int instance_concurrency: The maximum number of requests can be executed concurrently within the single function instance.
        :param builtins.str instance_type: The instance type of the function.
        :param builtins.str last_modification_time: Function last modification time.
        :param builtins.int memory_size: Amount of memory in MB the function can use at runtime.
        :param builtins.str name: Function name.
        :param builtins.str runtime: Function runtime. The list of possible values is [available here](https://www.alibabacloud.com/help/doc-detail/52077.htm).
        :param builtins.int timeout: Maximum amount of time the function can run in seconds.
        :param 'GetFunctionsFunctionCustomContainerConfigArgs' custom_container_config: The configuration for custom container runtime. It contains following attributes:
        """
        pulumi.set(__self__, "ca_port", ca_port)
        pulumi.set(__self__, "code_checksum", code_checksum)
        pulumi.set(__self__, "code_size", code_size)
        pulumi.set(__self__, "creation_time", creation_time)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "environment_variables", environment_variables)
        pulumi.set(__self__, "handler", handler)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "initialization_timeout", initialization_timeout)
        pulumi.set(__self__, "initializer", initializer)
        pulumi.set(__self__, "instance_concurrency", instance_concurrency)
        pulumi.set(__self__, "instance_type", instance_type)
        pulumi.set(__self__, "last_modification_time", last_modification_time)
        pulumi.set(__self__, "memory_size", memory_size)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "runtime", runtime)
        pulumi.set(__self__, "timeout", timeout)
        if custom_container_config is not None:
            pulumi.set(__self__, "custom_container_config", custom_container_config)

    @property
    @pulumi.getter(name="caPort")
    def ca_port(self) -> builtins.int:
        """
        The port that the function listen to, only valid for [custom runtime](https://www.alibabacloud.com/help/doc-detail/132044.htm) and [custom container runtime](https://www.alibabacloud.com/help/doc-detail/179368.htm).
        """
        return pulumi.get(self, "ca_port")

    @property
    @pulumi.getter(name="codeChecksum")
    def code_checksum(self) -> builtins.str:
        """
        Checksum (crc64) of the function code.
        """
        return pulumi.get(self, "code_checksum")

    @property
    @pulumi.getter(name="codeSize")
    def code_size(self) -> builtins.int:
        """
        Function code size in bytes.
        """
        return pulumi.get(self, "code_size")

    @property
    @pulumi.getter(name="creationTime")
    def creation_time(self) -> builtins.str:
        """
        Function creation time.
        """
        return pulumi.get(self, "creation_time")

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

    @property
    @pulumi.getter(name="environmentVariables")
    def environment_variables(self) -> Mapping[str, builtins.str]:
        """
        A map that defines environment variables for the function.
        """
        return pulumi.get(self, "environment_variables")

    @property
    @pulumi.getter
    def handler(self) -> builtins.str:
        """
        Function [entry point](https://www.alibabacloud.com/help/doc-detail/62213.htm) in the code.
        """
        return pulumi.get(self, "handler")

    @property
    @pulumi.getter
    def id(self) -> builtins.str:
        """
        Function ID.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="initializationTimeout")
    def initialization_timeout(self) -> builtins.int:
        """
        The maximum length of time, in seconds, that the function's initialization should be run for.
        """
        return pulumi.get(self, "initialization_timeout")

    @property
    @pulumi.getter
    def initializer(self) -> builtins.str:
        """
        The entry point of the function's [initialization](https://www.alibabacloud.com/help/doc-detail/157704.htm).
        """
        return pulumi.get(self, "initializer")

    @property
    @pulumi.getter(name="instanceConcurrency")
    def instance_concurrency(self) -> builtins.int:
        """
        The maximum number of requests can be executed concurrently within the single function instance.
        """
        return pulumi.get(self, "instance_concurrency")

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> builtins.str:
        """
        The instance type of the function.
        """
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter(name="lastModificationTime")
    def last_modification_time(self) -> builtins.str:
        """
        Function last modification time.
        """
        return pulumi.get(self, "last_modification_time")

    @property
    @pulumi.getter(name="memorySize")
    def memory_size(self) -> builtins.int:
        """
        Amount of memory in MB the function can use at runtime.
        """
        return pulumi.get(self, "memory_size")

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

    @property
    @pulumi.getter
    def runtime(self) -> builtins.str:
        """
        Function runtime. The list of possible values is [available here](https://www.alibabacloud.com/help/doc-detail/52077.htm).
        """
        return pulumi.get(self, "runtime")

    @property
    @pulumi.getter
    def timeout(self) -> builtins.int:
        """
        Maximum amount of time the function can run in seconds.
        """
        return pulumi.get(self, "timeout")

    @property
    @pulumi.getter(name="customContainerConfig")
    def custom_container_config(self) -> Optional['outputs.GetFunctionsFunctionCustomContainerConfigResult']:
        """
        The configuration for custom container runtime. It contains following attributes:
        """
        return pulumi.get(self, "custom_container_config")


@pulumi.output_type
class GetFunctionsFunctionCustomContainerConfigResult(dict):
    def __init__(__self__, *,
                 args: builtins.str,
                 command: builtins.str,
                 image: builtins.str):
        """
        :param builtins.str args: The args field specifies the arguments passed to the command.
        :param builtins.str command: The entry point of the container, which specifies the actual command run by the container.
        :param builtins.str image: The container image address.
        """
        pulumi.set(__self__, "args", args)
        pulumi.set(__self__, "command", command)
        pulumi.set(__self__, "image", image)

    @property
    @pulumi.getter
    def args(self) -> builtins.str:
        """
        The args field specifies the arguments passed to the command.
        """
        return pulumi.get(self, "args")

    @property
    @pulumi.getter
    def command(self) -> builtins.str:
        """
        The entry point of the container, which specifies the actual command run by the container.
        """
        return pulumi.get(self, "command")

    @property
    @pulumi.getter
    def image(self) -> builtins.str:
        """
        The container image address.
        """
        return pulumi.get(self, "image")


@pulumi.output_type
class GetServicesServiceResult(dict):
    def __init__(__self__, *,
                 creation_time: builtins.str,
                 description: builtins.str,
                 id: builtins.str,
                 internet_access: builtins.bool,
                 last_modification_time: builtins.str,
                 log_config: 'outputs.GetServicesServiceLogConfigResult',
                 name: builtins.str,
                 nas_config: 'outputs.GetServicesServiceNasConfigResult',
                 role: builtins.str,
                 vpc_config: 'outputs.GetServicesServiceVpcConfigResult'):
        """
        :param builtins.str creation_time: FC service creation time.
        :param builtins.str description: FC service description.
        :param builtins.str id: FC service ID.
        :param builtins.bool internet_access: Indicate whether the service can access to internet or not.
        :param builtins.str last_modification_time: FC service last modification time.
        :param 'GetServicesServiceLogConfigArgs' log_config: A list of one element containing information about the associated log store. It contains the following attributes:
        :param builtins.str name: FC service name.
        :param 'GetServicesServiceNasConfigArgs' nas_config: A list of one element about the nas configuration.
        :param builtins.str role: FC service role ARN.
        :param 'GetServicesServiceVpcConfigArgs' vpc_config: A list of one element containing information about accessible VPC resources. It contains the following attributes:
        """
        pulumi.set(__self__, "creation_time", creation_time)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "internet_access", internet_access)
        pulumi.set(__self__, "last_modification_time", last_modification_time)
        pulumi.set(__self__, "log_config", log_config)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "nas_config", nas_config)
        pulumi.set(__self__, "role", role)
        pulumi.set(__self__, "vpc_config", vpc_config)

    @property
    @pulumi.getter(name="creationTime")
    def creation_time(self) -> builtins.str:
        """
        FC service creation time.
        """
        return pulumi.get(self, "creation_time")

    @property
    @pulumi.getter
    def description(self) -> builtins.str:
        """
        FC service description.
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter
    def id(self) -> builtins.str:
        """
        FC service ID.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="internetAccess")
    def internet_access(self) -> builtins.bool:
        """
        Indicate whether the service can access to internet or not.
        """
        return pulumi.get(self, "internet_access")

    @property
    @pulumi.getter(name="lastModificationTime")
    def last_modification_time(self) -> builtins.str:
        """
        FC service last modification time.
        """
        return pulumi.get(self, "last_modification_time")

    @property
    @pulumi.getter(name="logConfig")
    def log_config(self) -> 'outputs.GetServicesServiceLogConfigResult':
        """
        A list of one element containing information about the associated log store. It contains the following attributes:
        """
        return pulumi.get(self, "log_config")

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        FC service name.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="nasConfig")
    def nas_config(self) -> 'outputs.GetServicesServiceNasConfigResult':
        """
        A list of one element about the nas configuration.
        """
        return pulumi.get(self, "nas_config")

    @property
    @pulumi.getter
    def role(self) -> builtins.str:
        """
        FC service role ARN.
        """
        return pulumi.get(self, "role")

    @property
    @pulumi.getter(name="vpcConfig")
    def vpc_config(self) -> 'outputs.GetServicesServiceVpcConfigResult':
        """
        A list of one element containing information about accessible VPC resources. It contains the following attributes:
        """
        return pulumi.get(self, "vpc_config")


@pulumi.output_type
class GetServicesServiceLogConfigResult(dict):
    def __init__(__self__, *,
                 logstore: builtins.str,
                 project: builtins.str):
        """
        :param builtins.str logstore: Log Service store name.
        :param builtins.str project: Log Service project name.
        """
        pulumi.set(__self__, "logstore", logstore)
        pulumi.set(__self__, "project", project)

    @property
    @pulumi.getter
    def logstore(self) -> builtins.str:
        """
        Log Service store name.
        """
        return pulumi.get(self, "logstore")

    @property
    @pulumi.getter
    def project(self) -> builtins.str:
        """
        Log Service project name.
        """
        return pulumi.get(self, "project")


@pulumi.output_type
class GetServicesServiceNasConfigResult(dict):
    def __init__(__self__, *,
                 group_id: builtins.int,
                 mount_points: Sequence['outputs.GetServicesServiceNasConfigMountPointResult'],
                 user_id: builtins.int):
        """
        :param builtins.int group_id: The group id of the NAS file system.
        :param Sequence['GetServicesServiceNasConfigMountPointArgs'] mount_points: The mount points configuration, including following attributes:
        :param builtins.int user_id: The user id of the NAS file system.
        """
        pulumi.set(__self__, "group_id", group_id)
        pulumi.set(__self__, "mount_points", mount_points)
        pulumi.set(__self__, "user_id", user_id)

    @property
    @pulumi.getter(name="groupId")
    def group_id(self) -> builtins.int:
        """
        The group id of the NAS file system.
        """
        return pulumi.get(self, "group_id")

    @property
    @pulumi.getter(name="mountPoints")
    def mount_points(self) -> Sequence['outputs.GetServicesServiceNasConfigMountPointResult']:
        """
        The mount points configuration, including following attributes:
        """
        return pulumi.get(self, "mount_points")

    @property
    @pulumi.getter(name="userId")
    def user_id(self) -> builtins.int:
        """
        The user id of the NAS file system.
        """
        return pulumi.get(self, "user_id")


@pulumi.output_type
class GetServicesServiceNasConfigMountPointResult(dict):
    def __init__(__self__, *,
                 mount_dir: builtins.str,
                 server_addr: builtins.str):
        """
        :param builtins.str mount_dir: The local address where to mount your remote NAS directory.
        :param builtins.str server_addr: The address of the remote NAS directory.
        """
        pulumi.set(__self__, "mount_dir", mount_dir)
        pulumi.set(__self__, "server_addr", server_addr)

    @property
    @pulumi.getter(name="mountDir")
    def mount_dir(self) -> builtins.str:
        """
        The local address where to mount your remote NAS directory.
        """
        return pulumi.get(self, "mount_dir")

    @property
    @pulumi.getter(name="serverAddr")
    def server_addr(self) -> builtins.str:
        """
        The address of the remote NAS directory.
        """
        return pulumi.get(self, "server_addr")


@pulumi.output_type
class GetServicesServiceVpcConfigResult(dict):
    def __init__(__self__, *,
                 security_group_id: builtins.str,
                 vpc_id: builtins.str,
                 vswitch_ids: Sequence[builtins.str]):
        """
        :param builtins.str security_group_id: Associated security group ID.
        :param builtins.str vpc_id: Associated VPC ID.
        :param Sequence[builtins.str] vswitch_ids: Associated vSwitch IDs.
        """
        pulumi.set(__self__, "security_group_id", security_group_id)
        pulumi.set(__self__, "vpc_id", vpc_id)
        pulumi.set(__self__, "vswitch_ids", vswitch_ids)

    @property
    @pulumi.getter(name="securityGroupId")
    def security_group_id(self) -> builtins.str:
        """
        Associated security group ID.
        """
        return pulumi.get(self, "security_group_id")

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

    @property
    @pulumi.getter(name="vswitchIds")
    def vswitch_ids(self) -> Sequence[builtins.str]:
        """
        Associated vSwitch IDs.
        """
        return pulumi.get(self, "vswitch_ids")


@pulumi.output_type
class GetTriggersTriggerResult(dict):
    def __init__(__self__, *,
                 config: builtins.str,
                 creation_time: builtins.str,
                 id: builtins.str,
                 invocation_role: builtins.str,
                 last_modification_time: builtins.str,
                 name: builtins.str,
                 source_arn: builtins.str,
                 type: builtins.str):
        """
        :param builtins.str config: JSON-encoded trigger configuration. See [Configure triggers and events](https://www.alibabacloud.com/help/doc-detail/70140.htm) for more details.
        :param builtins.str creation_time: FC trigger creation time.
        :param builtins.str id: FC trigger ID.
        :param builtins.str invocation_role: RAM role arn attached to the Function Compute trigger. Role used by the event source to call the function. The value format is "acs:ram::$account-id:role/$role-name". See [Create a trigger](https://www.alibabacloud.com/help/doc-detail/53102.htm) for more details.
        :param builtins.str last_modification_time: FC trigger last modification time.
        :param builtins.str name: FC trigger name.
        :param builtins.str source_arn: Event source resource address. See [Create a trigger](https://www.alibabacloud.com/help/doc-detail/53102.htm) for more details.
        :param builtins.str type: Type of the trigger. Valid values: `oss`, `log`, `timer`, `http`, `mns_topic`, `cdn_events` and `eventbridge`.
        """
        pulumi.set(__self__, "config", config)
        pulumi.set(__self__, "creation_time", creation_time)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "invocation_role", invocation_role)
        pulumi.set(__self__, "last_modification_time", last_modification_time)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "source_arn", source_arn)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def config(self) -> builtins.str:
        """
        JSON-encoded trigger configuration. See [Configure triggers and events](https://www.alibabacloud.com/help/doc-detail/70140.htm) for more details.
        """
        return pulumi.get(self, "config")

    @property
    @pulumi.getter(name="creationTime")
    def creation_time(self) -> builtins.str:
        """
        FC trigger creation time.
        """
        return pulumi.get(self, "creation_time")

    @property
    @pulumi.getter
    def id(self) -> builtins.str:
        """
        FC trigger ID.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="invocationRole")
    def invocation_role(self) -> builtins.str:
        """
        RAM role arn attached to the Function Compute trigger. Role used by the event source to call the function. The value format is "acs:ram::$account-id:role/$role-name". See [Create a trigger](https://www.alibabacloud.com/help/doc-detail/53102.htm) for more details.
        """
        return pulumi.get(self, "invocation_role")

    @property
    @pulumi.getter(name="lastModificationTime")
    def last_modification_time(self) -> builtins.str:
        """
        FC trigger last modification time.
        """
        return pulumi.get(self, "last_modification_time")

    @property
    @pulumi.getter
    def name(self) -> builtins.str:
        """
        FC trigger name.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="sourceArn")
    def source_arn(self) -> builtins.str:
        """
        Event source resource address. See [Create a trigger](https://www.alibabacloud.com/help/doc-detail/53102.htm) for more details.
        """
        return pulumi.get(self, "source_arn")

    @property
    @pulumi.getter
    def type(self) -> builtins.str:
        """
        Type of the trigger. Valid values: `oss`, `log`, `timer`, `http`, `mns_topic`, `cdn_events` and `eventbridge`.
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetV3TriggersTriggerResult(dict):
    def __init__(__self__, *,
                 create_time: builtins.str,
                 description: builtins.str,
                 http_trigger: 'outputs.GetV3TriggersTriggerHttpTriggerResult',
                 id: builtins.str,
                 invocation_role: builtins.str,
                 last_modified_time: builtins.str,
                 qualifier: builtins.str,
                 source_arn: builtins.str,
                 status: builtins.str,
                 target_arn: builtins.str,
                 trigger_config: builtins.str,
                 trigger_id: builtins.str,
                 trigger_name: builtins.str,
                 trigger_type: builtins.str):
        """
        :param builtins.str create_time: Creation time
        :param builtins.str description: Description of the trigger
        :param 'GetV3TriggersTriggerHttpTriggerArgs' http_trigger: HTTP trigger information
        :param builtins.str id: The ID of the resource supplied above.
        :param builtins.str invocation_role: The role required by the event source (such as OSS) to call the function.
        :param builtins.str last_modified_time: The last modified time of the trigger
        :param builtins.str qualifier: The version or alias of the function
        :param builtins.str source_arn: Trigger Event source ARN
        :param builtins.str status: The state of the trigger
        :param builtins.str target_arn: Resource identity of the function
        :param builtins.str trigger_config: Trigger configuration. The configuration varies for different types of triggers.
        :param builtins.str trigger_id: Trigger ID
        :param builtins.str trigger_name: Trigger Name
        :param builtins.str trigger_type: The type of the trigger. Currently, the supported types include oss, log, http, timer, tablestore, cdn_events, mns_topic and eventbridge.
        """
        pulumi.set(__self__, "create_time", create_time)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "http_trigger", http_trigger)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "invocation_role", invocation_role)
        pulumi.set(__self__, "last_modified_time", last_modified_time)
        pulumi.set(__self__, "qualifier", qualifier)
        pulumi.set(__self__, "source_arn", source_arn)
        pulumi.set(__self__, "status", status)
        pulumi.set(__self__, "target_arn", target_arn)
        pulumi.set(__self__, "trigger_config", trigger_config)
        pulumi.set(__self__, "trigger_id", trigger_id)
        pulumi.set(__self__, "trigger_name", trigger_name)
        pulumi.set(__self__, "trigger_type", trigger_type)

    @property
    @pulumi.getter(name="createTime")
    def create_time(self) -> builtins.str:
        """
        Creation time
        """
        return pulumi.get(self, "create_time")

    @property
    @pulumi.getter
    def description(self) -> builtins.str:
        """
        Description of the trigger
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="httpTrigger")
    def http_trigger(self) -> 'outputs.GetV3TriggersTriggerHttpTriggerResult':
        """
        HTTP trigger information
        """
        return pulumi.get(self, "http_trigger")

    @property
    @pulumi.getter
    def id(self) -> builtins.str:
        """
        The ID of the resource supplied above.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="invocationRole")
    def invocation_role(self) -> builtins.str:
        """
        The role required by the event source (such as OSS) to call the function.
        """
        return pulumi.get(self, "invocation_role")

    @property
    @pulumi.getter(name="lastModifiedTime")
    def last_modified_time(self) -> builtins.str:
        """
        The last modified time of the trigger
        """
        return pulumi.get(self, "last_modified_time")

    @property
    @pulumi.getter
    def qualifier(self) -> builtins.str:
        """
        The version or alias of the function
        """
        return pulumi.get(self, "qualifier")

    @property
    @pulumi.getter(name="sourceArn")
    def source_arn(self) -> builtins.str:
        """
        Trigger Event source ARN
        """
        return pulumi.get(self, "source_arn")

    @property
    @pulumi.getter
    def status(self) -> builtins.str:
        """
        The state of the trigger
        """
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="targetArn")
    def target_arn(self) -> builtins.str:
        """
        Resource identity of the function
        """
        return pulumi.get(self, "target_arn")

    @property
    @pulumi.getter(name="triggerConfig")
    def trigger_config(self) -> builtins.str:
        """
        Trigger configuration. The configuration varies for different types of triggers.
        """
        return pulumi.get(self, "trigger_config")

    @property
    @pulumi.getter(name="triggerId")
    def trigger_id(self) -> builtins.str:
        """
        Trigger ID
        """
        return pulumi.get(self, "trigger_id")

    @property
    @pulumi.getter(name="triggerName")
    def trigger_name(self) -> builtins.str:
        """
        Trigger Name
        """
        return pulumi.get(self, "trigger_name")

    @property
    @pulumi.getter(name="triggerType")
    def trigger_type(self) -> builtins.str:
        """
        The type of the trigger. Currently, the supported types include oss, log, http, timer, tablestore, cdn_events, mns_topic and eventbridge.
        """
        return pulumi.get(self, "trigger_type")


@pulumi.output_type
class GetV3TriggersTriggerHttpTriggerResult(dict):
    def __init__(__self__, *,
                 url_internet: builtins.str,
                 url_intranet: builtins.str):
        """
        :param builtins.str url_internet: The public domain name address. On the Internet, you can access the HTTP Trigger through the HTTP protocol or HTTPS protocol.
        :param builtins.str url_intranet: The private domain name address. In a VPC, you can access the HTTP Trigger through HTTP or HTTPS.
        """
        pulumi.set(__self__, "url_internet", url_internet)
        pulumi.set(__self__, "url_intranet", url_intranet)

    @property
    @pulumi.getter(name="urlInternet")
    def url_internet(self) -> builtins.str:
        """
        The public domain name address. On the Internet, you can access the HTTP Trigger through the HTTP protocol or HTTPS protocol.
        """
        return pulumi.get(self, "url_internet")

    @property
    @pulumi.getter(name="urlIntranet")
    def url_intranet(self) -> builtins.str:
        """
        The private domain name address. In a VPC, you can access the HTTP Trigger through HTTP or HTTPS.
        """
        return pulumi.get(self, "url_intranet")


@pulumi.output_type
class GetZonesZoneResult(dict):
    def __init__(__self__, *,
                 id: builtins.str):
        """
        :param builtins.str id: ID of the zone.
        """
        pulumi.set(__self__, "id", id)

    @property
    @pulumi.getter
    def id(self) -> builtins.str:
        """
        ID of the zone.
        """
        return pulumi.get(self, "id")


