pulumi-alicloud 3.75.0a1741324537__py3-none-any.whl → 3.76.0__py3-none-any.whl

pulumi_alicloud/esa/outputs.py

@@ -13,11 +13,23 @@ if sys.version_info >= (3, 11):
 else:
     from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
+from . import outputs
 
 __all__ = [
     'HttpRequestHeaderModificationRuleRequestHeaderModification',
+    'HttpResponseHeaderModificationRuleResponseHeaderModification',
+    'OriginPoolOrigin',
+    'OriginPoolOriginAuthConf',
     'RecordAuthConf',
     'RecordData',
+    'SiteDeliveryTaskHttpDelivery',
+    'SiteDeliveryTaskHttpDeliveryStandardAuthParam',
+    'SiteDeliveryTaskKafkaDelivery',
+    'SiteDeliveryTaskOssDelivery',
+    'SiteDeliveryTaskS3Delivery',
+    'SiteDeliveryTaskSlsDelivery',
+    'WaitingRoomHostNameAndPath',
+    'GetSitesSiteResult',
 ]
 
 @pulumi.output_type
@@ -29,9 +41,6 @@ class HttpRequestHeaderModificationRuleRequestHeaderModification(dict):
         """
         :param str name: Request Header Name.
         :param str operation: Mode of operation. Value range:
-               add: add.
-               del: delete
-               modify: change.
         :param str value: Request header value
         """
         pulumi.set(__self__, "name", name)
@@ -52,9 +61,6 @@ class HttpRequestHeaderModificationRuleRequestHeaderModification(dict):
     def operation(self) -> str:
         """
         Mode of operation. Value range:
-        add: add.
-        del: delete
-        modify: change.
         """
         return pulumi.get(self, "operation")
 
@@ -67,6 +73,263 @@ class HttpRequestHeaderModificationRuleRequestHeaderModification(dict):
         return pulumi.get(self, "value")
 
 
+@pulumi.output_type
+class HttpResponseHeaderModificationRuleResponseHeaderModification(dict):
+    def __init__(__self__, *,
+                 name: str,
+                 operation: str,
+                 value: Optional[str] = None):
+        """
+        :param str name: The response header name.
+        :param str operation: Operation method. Possible values:
+        :param str value: The response header value.
+        """
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "operation", operation)
+        if value is not None:
+            pulumi.set(__self__, "value", value)
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        The response header name.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def operation(self) -> str:
+        """
+        Operation method. Possible values:
+        """
+        return pulumi.get(self, "operation")
+
+    @property
+    @pulumi.getter
+    def value(self) -> Optional[str]:
+        """
+        The response header value.
+        """
+        return pulumi.get(self, "value")
+
+
+@pulumi.output_type
+class OriginPoolOrigin(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "authConf":
+            suggest = "auth_conf"
+        elif key == "originId":
+            suggest = "origin_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in OriginPoolOrigin. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        OriginPoolOrigin.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        OriginPoolOrigin.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 address: Optional[str] = None,
+                 auth_conf: Optional['outputs.OriginPoolOriginAuthConf'] = None,
+                 enabled: Optional[bool] = None,
+                 header: Optional[str] = None,
+                 name: Optional[str] = None,
+                 origin_id: Optional[int] = None,
+                 type: Optional[str] = None,
+                 weight: Optional[int] = None):
+        """
+        :param str address: Origin Address.
+        :param 'OriginPoolOriginAuthConfArgs' auth_conf: The authentication information. When the source Station is an OSS or S3 and other source stations need to be authenticated, the authentication-related configuration information needs to be transmitted. See `auth_conf` below.
+        :param bool enabled: Whether the source station is enabled:
+        :param str header: The request header that is sent when returning to the source. Only Host is supported.
+        :param str name: Origin Name.
+        :param int origin_id: Origin ID.
+        :param str type: Source station type:
+               ip_domain: ip or domain name type origin station;
+               - `OSS`:OSS address source station;
+               - `S3`:AWS S3 Source station.
+        :param int weight: Weight, 0-100.
+        """
+        if address is not None:
+            pulumi.set(__self__, "address", address)
+        if auth_conf is not None:
+            pulumi.set(__self__, "auth_conf", auth_conf)
+        if enabled is not None:
+            pulumi.set(__self__, "enabled", enabled)
+        if header is not None:
+            pulumi.set(__self__, "header", header)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if origin_id is not None:
+            pulumi.set(__self__, "origin_id", origin_id)
+        if type is not None:
+            pulumi.set(__self__, "type", type)
+        if weight is not None:
+            pulumi.set(__self__, "weight", weight)
+
+    @property
+    @pulumi.getter
+    def address(self) -> Optional[str]:
+        """
+        Origin Address.
+        """
+        return pulumi.get(self, "address")
+
+    @property
+    @pulumi.getter(name="authConf")
+    def auth_conf(self) -> Optional['outputs.OriginPoolOriginAuthConf']:
+        """
+        The authentication information. When the source Station is an OSS or S3 and other source stations need to be authenticated, the authentication-related configuration information needs to be transmitted. See `auth_conf` below.
+        """
+        return pulumi.get(self, "auth_conf")
+
+    @property
+    @pulumi.getter
+    def enabled(self) -> Optional[bool]:
+        """
+        Whether the source station is enabled:
+        """
+        return pulumi.get(self, "enabled")
+
+    @property
+    @pulumi.getter
+    def header(self) -> Optional[str]:
+        """
+        The request header that is sent when returning to the source. Only Host is supported.
+        """
+        return pulumi.get(self, "header")
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[str]:
+        """
+        Origin Name.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="originId")
+    def origin_id(self) -> Optional[int]:
+        """
+        Origin ID.
+        """
+        return pulumi.get(self, "origin_id")
+
+    @property
+    @pulumi.getter
+    def type(self) -> Optional[str]:
+        """
+        Source station type:
+        ip_domain: ip or domain name type origin station;
+        - `OSS`:OSS address source station;
+        - `S3`:AWS S3 Source station.
+        """
+        return pulumi.get(self, "type")
+
+    @property
+    @pulumi.getter
+    def weight(self) -> Optional[int]:
+        """
+        Weight, 0-100.
+        """
+        return pulumi.get(self, "weight")
+
+
+@pulumi.output_type
+class OriginPoolOriginAuthConf(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "accessKey":
+            suggest = "access_key"
+        elif key == "authType":
+            suggest = "auth_type"
+        elif key == "secretKey":
+            suggest = "secret_key"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in OriginPoolOriginAuthConf. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        OriginPoolOriginAuthConf.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        OriginPoolOriginAuthConf.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 access_key: Optional[str] = None,
+                 auth_type: Optional[str] = None,
+                 region: Optional[str] = None,
+                 secret_key: Optional[str] = None,
+                 version: Optional[str] = None):
+        """
+        :param str access_key: The AccessKey to be passed when AuthType is set to private_cross_account or private.
+        :param str auth_type: Authentication type.
+        :param str region: The Region of the source station to be transmitted when the source station is AWS S3.
+        :param str secret_key: The SecretKey to be passed when AuthType is set to private_cross_account or private.
+        :param str version: The signature version to be transmitted when the source station is AWS S3.
+        """
+        if access_key is not None:
+            pulumi.set(__self__, "access_key", access_key)
+        if auth_type is not None:
+            pulumi.set(__self__, "auth_type", auth_type)
+        if region is not None:
+            pulumi.set(__self__, "region", region)
+        if secret_key is not None:
+            pulumi.set(__self__, "secret_key", secret_key)
+        if version is not None:
+            pulumi.set(__self__, "version", version)
+
+    @property
+    @pulumi.getter(name="accessKey")
+    def access_key(self) -> Optional[str]:
+        """
+        The AccessKey to be passed when AuthType is set to private_cross_account or private.
+        """
+        return pulumi.get(self, "access_key")
+
+    @property
+    @pulumi.getter(name="authType")
+    def auth_type(self) -> Optional[str]:
+        """
+        Authentication type.
+        """
+        return pulumi.get(self, "auth_type")
+
+    @property
+    @pulumi.getter
+    def region(self) -> Optional[str]:
+        """
+        The Region of the source station to be transmitted when the source station is AWS S3.
+        """
+        return pulumi.get(self, "region")
+
+    @property
+    @pulumi.getter(name="secretKey")
+    def secret_key(self) -> Optional[str]:
+        """
+        The SecretKey to be passed when AuthType is set to private_cross_account or private.
+        """
+        return pulumi.get(self, "secret_key")
+
+    @property
+    @pulumi.getter
+    def version(self) -> Optional[str]:
+        """
+        The signature version to be transmitted when the source station is AWS S3.
+        """
+        return pulumi.get(self, "version")
+
+
 @pulumi.output_type
 class RecordAuthConf(dict):
     @staticmethod
@@ -99,9 +362,9 @@ class RecordAuthConf(dict):
         """
         :param str access_key: The access key of the account to which the origin server belongs. This parameter is required when the SourceType is OSS, and AuthType is private_same_account, or when the SourceType is S3 and AuthType is private.
         :param str auth_type: The authentication type of the origin server. Different origins support different authentication types. The type of origin refers to the SourceType parameter in this operation. If the type of origin is OSS or S3, you must specify the authentication type of the origin. Valid values:
-        :param str region: The version of the signature algorithm. This parameter is required when the origin type is S3 and AuthType is private. The following two types are supported:
+        :param str region: The region of the origin. If the origin type is S3, you must specify this value. You can get the region information from the official website of S3.
         :param str secret_key: The secret access key of the account to which the origin server belongs. This parameter is required when the SourceType is OSS, and AuthType is private_same_account, or when the SourceType is S3 and AuthType is private.
-        :param str version: The region of the origin. If the origin type is S3, you must specify this value. You can get the region information from the official website of S3.
+        :param str version: The version of the signature algorithm. This parameter is required when the origin type is S3 and AuthType is private. The following two types are supported:
         """
         if access_key is not None:
             pulumi.set(__self__, "access_key", access_key)
@@ -134,7 +397,7 @@ class RecordAuthConf(dict):
     @pulumi.getter
     def region(self) -> Optional[str]:
         """
-        The version of the signature algorithm. This parameter is required when the origin type is S3 and AuthType is private. The following two types are supported:
+        The region of the origin. If the origin type is S3, you must specify this value. You can get the region information from the official website of S3.
         """
         return pulumi.get(self, "region")
 
@@ -150,7 +413,7 @@ class RecordAuthConf(dict):
     @pulumi.getter
     def version(self) -> Optional[str]:
         """
-        The region of the origin. If the origin type is S3, you must specify this value. You can get the region information from the official website of S3.
+        The version of the signature algorithm. This parameter is required when the origin type is S3 and AuthType is private. The following two types are supported:
         """
         return pulumi.get(self, "version")
 
@@ -367,3 +630,689 @@ class RecordData(dict):
         return pulumi.get(self, "weight")
 
 
+@pulumi.output_type
+class SiteDeliveryTaskHttpDelivery(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "destUrl":
+            suggest = "dest_url"
+        elif key == "headerParam":
+            suggest = "header_param"
+        elif key == "logBodyPrefix":
+            suggest = "log_body_prefix"
+        elif key == "logBodySuffix":
+            suggest = "log_body_suffix"
+        elif key == "maxBatchMb":
+            suggest = "max_batch_mb"
+        elif key == "maxBatchSize":
+            suggest = "max_batch_size"
+        elif key == "maxRetry":
+            suggest = "max_retry"
+        elif key == "queryParam":
+            suggest = "query_param"
+        elif key == "standardAuthOn":
+            suggest = "standard_auth_on"
+        elif key == "standardAuthParam":
+            suggest = "standard_auth_param"
+        elif key == "transformTimeout":
+            suggest = "transform_timeout"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SiteDeliveryTaskHttpDelivery. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SiteDeliveryTaskHttpDelivery.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SiteDeliveryTaskHttpDelivery.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 compress: Optional[str] = None,
+                 dest_url: Optional[str] = None,
+                 header_param: Optional[Mapping[str, str]] = None,
+                 log_body_prefix: Optional[str] = None,
+                 log_body_suffix: Optional[str] = None,
+                 max_batch_mb: Optional[int] = None,
+                 max_batch_size: Optional[int] = None,
+                 max_retry: Optional[int] = None,
+                 query_param: Optional[Mapping[str, str]] = None,
+                 standard_auth_on: Optional[bool] = None,
+                 standard_auth_param: Optional['outputs.SiteDeliveryTaskHttpDeliveryStandardAuthParam'] = None,
+                 transform_timeout: Optional[int] = None):
+        """
+        :param 'SiteDeliveryTaskHttpDeliveryStandardAuthParamArgs' standard_auth_param: See `standard_auth_param` below.
+        """
+        if compress is not None:
+            pulumi.set(__self__, "compress", compress)
+        if dest_url is not None:
+            pulumi.set(__self__, "dest_url", dest_url)
+        if header_param is not None:
+            pulumi.set(__self__, "header_param", header_param)
+        if log_body_prefix is not None:
+            pulumi.set(__self__, "log_body_prefix", log_body_prefix)
+        if log_body_suffix is not None:
+            pulumi.set(__self__, "log_body_suffix", log_body_suffix)
+        if max_batch_mb is not None:
+            pulumi.set(__self__, "max_batch_mb", max_batch_mb)
+        if max_batch_size is not None:
+            pulumi.set(__self__, "max_batch_size", max_batch_size)
+        if max_retry is not None:
+            pulumi.set(__self__, "max_retry", max_retry)
+        if query_param is not None:
+            pulumi.set(__self__, "query_param", query_param)
+        if standard_auth_on is not None:
+            pulumi.set(__self__, "standard_auth_on", standard_auth_on)
+        if standard_auth_param is not None:
+            pulumi.set(__self__, "standard_auth_param", standard_auth_param)
+        if transform_timeout is not None:
+            pulumi.set(__self__, "transform_timeout", transform_timeout)
+
+    @property
+    @pulumi.getter
+    def compress(self) -> Optional[str]:
+        return pulumi.get(self, "compress")
+
+    @property
+    @pulumi.getter(name="destUrl")
+    def dest_url(self) -> Optional[str]:
+        return pulumi.get(self, "dest_url")
+
+    @property
+    @pulumi.getter(name="headerParam")
+    def header_param(self) -> Optional[Mapping[str, str]]:
+        return pulumi.get(self, "header_param")
+
+    @property
+    @pulumi.getter(name="logBodyPrefix")
+    def log_body_prefix(self) -> Optional[str]:
+        return pulumi.get(self, "log_body_prefix")
+
+    @property
+    @pulumi.getter(name="logBodySuffix")
+    def log_body_suffix(self) -> Optional[str]:
+        return pulumi.get(self, "log_body_suffix")
+
+    @property
+    @pulumi.getter(name="maxBatchMb")
+    def max_batch_mb(self) -> Optional[int]:
+        return pulumi.get(self, "max_batch_mb")
+
+    @property
+    @pulumi.getter(name="maxBatchSize")
+    def max_batch_size(self) -> Optional[int]:
+        return pulumi.get(self, "max_batch_size")
+
+    @property
+    @pulumi.getter(name="maxRetry")
+    def max_retry(self) -> Optional[int]:
+        return pulumi.get(self, "max_retry")
+
+    @property
+    @pulumi.getter(name="queryParam")
+    def query_param(self) -> Optional[Mapping[str, str]]:
+        return pulumi.get(self, "query_param")
+
+    @property
+    @pulumi.getter(name="standardAuthOn")
+    def standard_auth_on(self) -> Optional[bool]:
+        return pulumi.get(self, "standard_auth_on")
+
+    @property
+    @pulumi.getter(name="standardAuthParam")
+    def standard_auth_param(self) -> Optional['outputs.SiteDeliveryTaskHttpDeliveryStandardAuthParam']:
+        """
+        See `standard_auth_param` below.
+        """
+        return pulumi.get(self, "standard_auth_param")
+
+    @property
+    @pulumi.getter(name="transformTimeout")
+    def transform_timeout(self) -> Optional[int]:
+        return pulumi.get(self, "transform_timeout")
+
+
+@pulumi.output_type
+class SiteDeliveryTaskHttpDeliveryStandardAuthParam(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "expiredTime":
+            suggest = "expired_time"
+        elif key == "privateKey":
+            suggest = "private_key"
+        elif key == "urlPath":
+            suggest = "url_path"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SiteDeliveryTaskHttpDeliveryStandardAuthParam. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SiteDeliveryTaskHttpDeliveryStandardAuthParam.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SiteDeliveryTaskHttpDeliveryStandardAuthParam.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 expired_time: Optional[int] = None,
+                 private_key: Optional[str] = None,
+                 url_path: Optional[str] = None):
+        if expired_time is not None:
+            pulumi.set(__self__, "expired_time", expired_time)
+        if private_key is not None:
+            pulumi.set(__self__, "private_key", private_key)
+        if url_path is not None:
+            pulumi.set(__self__, "url_path", url_path)
+
+    @property
+    @pulumi.getter(name="expiredTime")
+    def expired_time(self) -> Optional[int]:
+        return pulumi.get(self, "expired_time")
+
+    @property
+    @pulumi.getter(name="privateKey")
+    def private_key(self) -> Optional[str]:
+        return pulumi.get(self, "private_key")
+
+    @property
+    @pulumi.getter(name="urlPath")
+    def url_path(self) -> Optional[str]:
+        return pulumi.get(self, "url_path")
+
+
+@pulumi.output_type
+class SiteDeliveryTaskKafkaDelivery(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "machanismType":
+            suggest = "machanism_type"
+        elif key == "userAuth":
+            suggest = "user_auth"
+        elif key == "userName":
+            suggest = "user_name"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SiteDeliveryTaskKafkaDelivery. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SiteDeliveryTaskKafkaDelivery.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SiteDeliveryTaskKafkaDelivery.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 balancer: Optional[str] = None,
+                 brokers: Optional[Sequence[str]] = None,
+                 compress: Optional[str] = None,
+                 machanism_type: Optional[str] = None,
+                 password: Optional[str] = None,
+                 topic: Optional[str] = None,
+                 user_auth: Optional[bool] = None,
+                 user_name: Optional[str] = None):
+        """
+        :param str compress: The compression method. By default, data is not compressed.
+        """
+        if balancer is not None:
+            pulumi.set(__self__, "balancer", balancer)
+        if brokers is not None:
+            pulumi.set(__self__, "brokers", brokers)
+        if compress is not None:
+            pulumi.set(__self__, "compress", compress)
+        if machanism_type is not None:
+            pulumi.set(__self__, "machanism_type", machanism_type)
+        if password is not None:
+            pulumi.set(__self__, "password", password)
+        if topic is not None:
+            pulumi.set(__self__, "topic", topic)
+        if user_auth is not None:
+            pulumi.set(__self__, "user_auth", user_auth)
+        if user_name is not None:
+            pulumi.set(__self__, "user_name", user_name)
+
+    @property
+    @pulumi.getter
+    def balancer(self) -> Optional[str]:
+        return pulumi.get(self, "balancer")
+
+    @property
+    @pulumi.getter
+    def brokers(self) -> Optional[Sequence[str]]:
+        return pulumi.get(self, "brokers")
+
+    @property
+    @pulumi.getter
+    def compress(self) -> Optional[str]:
+        """
+        The compression method. By default, data is not compressed.
+        """
+        return pulumi.get(self, "compress")
+
+    @property
+    @pulumi.getter(name="machanismType")
+    def machanism_type(self) -> Optional[str]:
+        return pulumi.get(self, "machanism_type")
+
+    @property
+    @pulumi.getter
+    def password(self) -> Optional[str]:
+        return pulumi.get(self, "password")
+
+    @property
+    @pulumi.getter
+    def topic(self) -> Optional[str]:
+        return pulumi.get(self, "topic")
+
+    @property
+    @pulumi.getter(name="userAuth")
+    def user_auth(self) -> Optional[bool]:
+        return pulumi.get(self, "user_auth")
+
+    @property
+    @pulumi.getter(name="userName")
+    def user_name(self) -> Optional[str]:
+        return pulumi.get(self, "user_name")
+
+
+@pulumi.output_type
+class SiteDeliveryTaskOssDelivery(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "bucketName":
+            suggest = "bucket_name"
+        elif key == "prefixPath":
+            suggest = "prefix_path"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SiteDeliveryTaskOssDelivery. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SiteDeliveryTaskOssDelivery.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SiteDeliveryTaskOssDelivery.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 aliuid: Optional[str] = None,
+                 bucket_name: Optional[str] = None,
+                 prefix_path: Optional[str] = None,
+                 region: Optional[str] = None):
+        """
+        :param str region: The region ID of the service.
+        """
+        if aliuid is not None:
+            pulumi.set(__self__, "aliuid", aliuid)
+        if bucket_name is not None:
+            pulumi.set(__self__, "bucket_name", bucket_name)
+        if prefix_path is not None:
+            pulumi.set(__self__, "prefix_path", prefix_path)
+        if region is not None:
+            pulumi.set(__self__, "region", region)
+
+    @property
+    @pulumi.getter
+    def aliuid(self) -> Optional[str]:
+        return pulumi.get(self, "aliuid")
+
+    @property
+    @pulumi.getter(name="bucketName")
+    def bucket_name(self) -> Optional[str]:
+        return pulumi.get(self, "bucket_name")
+
+    @property
+    @pulumi.getter(name="prefixPath")
+    def prefix_path(self) -> Optional[str]:
+        return pulumi.get(self, "prefix_path")
+
+    @property
+    @pulumi.getter
+    def region(self) -> Optional[str]:
+        """
+        The region ID of the service.
+        """
+        return pulumi.get(self, "region")
+
+
+@pulumi.output_type
+class SiteDeliveryTaskS3Delivery(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "accessKey":
+            suggest = "access_key"
+        elif key == "bucketPath":
+            suggest = "bucket_path"
+        elif key == "prefixPath":
+            suggest = "prefix_path"
+        elif key == "s3Cmpt":
+            suggest = "s3_cmpt"
+        elif key == "secretKey":
+            suggest = "secret_key"
+        elif key == "serverSideEncryption":
+            suggest = "server_side_encryption"
+        elif key == "vertifyType":
+            suggest = "vertify_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SiteDeliveryTaskS3Delivery. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SiteDeliveryTaskS3Delivery.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SiteDeliveryTaskS3Delivery.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 access_key: Optional[str] = None,
+                 bucket_path: Optional[str] = None,
+                 endpoint: Optional[str] = None,
+                 prefix_path: Optional[str] = None,
+                 region: Optional[str] = None,
+                 s3_cmpt: Optional[bool] = None,
+                 secret_key: Optional[str] = None,
+                 server_side_encryption: Optional[bool] = None,
+                 vertify_type: Optional[str] = None):
+        """
+        :param bool server_side_encryption: Server-side encryption
+        :param str vertify_type: Authentication Type
+        """
+        if access_key is not None:
+            pulumi.set(__self__, "access_key", access_key)
+        if bucket_path is not None:
+            pulumi.set(__self__, "bucket_path", bucket_path)
+        if endpoint is not None:
+            pulumi.set(__self__, "endpoint", endpoint)
+        if prefix_path is not None:
+            pulumi.set(__self__, "prefix_path", prefix_path)
+        if region is not None:
+            pulumi.set(__self__, "region", region)
+        if s3_cmpt is not None:
+            pulumi.set(__self__, "s3_cmpt", s3_cmpt)
+        if secret_key is not None:
+            pulumi.set(__self__, "secret_key", secret_key)
+        if server_side_encryption is not None:
+            pulumi.set(__self__, "server_side_encryption", server_side_encryption)
+        if vertify_type is not None:
+            pulumi.set(__self__, "vertify_type", vertify_type)
+
+    @property
+    @pulumi.getter(name="accessKey")
+    def access_key(self) -> Optional[str]:
+        return pulumi.get(self, "access_key")
+
+    @property
+    @pulumi.getter(name="bucketPath")
+    def bucket_path(self) -> Optional[str]:
+        return pulumi.get(self, "bucket_path")
+
+    @property
+    @pulumi.getter
+    def endpoint(self) -> Optional[str]:
+        return pulumi.get(self, "endpoint")
+
+    @property
+    @pulumi.getter(name="prefixPath")
+    def prefix_path(self) -> Optional[str]:
+        return pulumi.get(self, "prefix_path")
+
+    @property
+    @pulumi.getter
+    def region(self) -> Optional[str]:
+        return pulumi.get(self, "region")
+
+    @property
+    @pulumi.getter(name="s3Cmpt")
+    def s3_cmpt(self) -> Optional[bool]:
+        return pulumi.get(self, "s3_cmpt")
+
+    @property
+    @pulumi.getter(name="secretKey")
+    def secret_key(self) -> Optional[str]:
+        return pulumi.get(self, "secret_key")
+
+    @property
+    @pulumi.getter(name="serverSideEncryption")
+    def server_side_encryption(self) -> Optional[bool]:
+        """
+        Server-side encryption
+        """
+        return pulumi.get(self, "server_side_encryption")
+
+    @property
+    @pulumi.getter(name="vertifyType")
+    def vertify_type(self) -> Optional[str]:
+        """
+        Authentication Type
+        """
+        return pulumi.get(self, "vertify_type")
+
+
+@pulumi.output_type
+class SiteDeliveryTaskSlsDelivery(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "slsLogStore":
+            suggest = "sls_log_store"
+        elif key == "slsProject":
+            suggest = "sls_project"
+        elif key == "slsRegion":
+            suggest = "sls_region"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in SiteDeliveryTaskSlsDelivery. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        SiteDeliveryTaskSlsDelivery.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        SiteDeliveryTaskSlsDelivery.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 sls_log_store: Optional[str] = None,
+                 sls_project: Optional[str] = None,
+                 sls_region: Optional[str] = None):
+        if sls_log_store is not None:
+            pulumi.set(__self__, "sls_log_store", sls_log_store)
+        if sls_project is not None:
+            pulumi.set(__self__, "sls_project", sls_project)
+        if sls_region is not None:
+            pulumi.set(__self__, "sls_region", sls_region)
+
+    @property
+    @pulumi.getter(name="slsLogStore")
+    def sls_log_store(self) -> Optional[str]:
+        return pulumi.get(self, "sls_log_store")
+
+    @property
+    @pulumi.getter(name="slsProject")
+    def sls_project(self) -> Optional[str]:
+        return pulumi.get(self, "sls_project")
+
+    @property
+    @pulumi.getter(name="slsRegion")
+    def sls_region(self) -> Optional[str]:
+        return pulumi.get(self, "sls_region")
+
+
+@pulumi.output_type
+class WaitingRoomHostNameAndPath(dict):
+    def __init__(__self__, *,
+                 domain: str,
+                 path: str,
+                 subdomain: str):
+        """
+        :param str domain: The domain name.
+        :param str path: The path.
+        :param str subdomain: The subdomain.
+        """
+        pulumi.set(__self__, "domain", domain)
+        pulumi.set(__self__, "path", path)
+        pulumi.set(__self__, "subdomain", subdomain)
+
+    @property
+    @pulumi.getter
+    def domain(self) -> str:
+        """
+        The domain name.
+        """
+        return pulumi.get(self, "domain")
+
+    @property
+    @pulumi.getter
+    def path(self) -> str:
+        """
+        The path.
+        """
+        return pulumi.get(self, "path")
+
+    @property
+    @pulumi.getter
+    def subdomain(self) -> str:
+        """
+        The subdomain.
+        """
+        return pulumi.get(self, "subdomain")
+
+
+@pulumi.output_type
+class GetSitesSiteResult(dict):
+    def __init__(__self__, *,
+                 access_type: str,
+                 coverage: str,
+                 create_time: str,
+                 id: int,
+                 instance_id: str,
+                 modify_time: str,
+                 name_server_list: str,
+                 resource_group_id: str,
+                 site_id: int,
+                 site_name: str,
+                 status: str):
+        """
+        :param str access_type: Access type. Value:-**NS**: Managed access via NS.-**CNAME**: access through CNAME.
+        :param str coverage: Acceleration area
+        :param str create_time: Creation time
+        :param int id: The ID of the resource supplied above.
+        :param str instance_id: The ID of the associated package instance.
+        :param str modify_time: Modification time
+        :param str name_server_list: Site Resolution Name Server List
+        :param str resource_group_id: The ID of the resource group
+        :param int site_id: Site ID
+        :param str site_name: Site Name
+        :param str status: The status of the resource
+        """
+        pulumi.set(__self__, "access_type", access_type)
+        pulumi.set(__self__, "coverage", coverage)
+        pulumi.set(__self__, "create_time", create_time)
+        pulumi.set(__self__, "id", id)
+        pulumi.set(__self__, "instance_id", instance_id)
+        pulumi.set(__self__, "modify_time", modify_time)
+        pulumi.set(__self__, "name_server_list", name_server_list)
+        pulumi.set(__self__, "resource_group_id", resource_group_id)
+        pulumi.set(__self__, "site_id", site_id)
+        pulumi.set(__self__, "site_name", site_name)
+        pulumi.set(__self__, "status", status)
+
+    @property
+    @pulumi.getter(name="accessType")
+    def access_type(self) -> str:
+        """
+        Access type. Value:-**NS**: Managed access via NS.-**CNAME**: access through CNAME.
+        """
+        return pulumi.get(self, "access_type")
+
+    @property
+    @pulumi.getter
+    def coverage(self) -> str:
+        """
+        Acceleration area
+        """
+        return pulumi.get(self, "coverage")
+
+    @property
+    @pulumi.getter(name="createTime")
+    def create_time(self) -> str:
+        """
+        Creation time
+        """
+        return pulumi.get(self, "create_time")
+
+    @property
+    @pulumi.getter
+    def id(self) -> int:
+        """
+        The ID of the resource supplied above.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter(name="instanceId")
+    def instance_id(self) -> str:
+        """
+        The ID of the associated package instance.
+        """
+        return pulumi.get(self, "instance_id")
+
+    @property
+    @pulumi.getter(name="modifyTime")
+    def modify_time(self) -> str:
+        """
+        Modification time
+        """
+        return pulumi.get(self, "modify_time")
+
+    @property
+    @pulumi.getter(name="nameServerList")
+    def name_server_list(self) -> str:
+        """
+        Site Resolution Name Server List
+        """
+        return pulumi.get(self, "name_server_list")
+
+    @property
+    @pulumi.getter(name="resourceGroupId")
+    def resource_group_id(self) -> str:
+        """
+        The ID of the resource group
+        """
+        return pulumi.get(self, "resource_group_id")
+
+    @property
+    @pulumi.getter(name="siteId")
+    def site_id(self) -> int:
+        """
+        Site ID
+        """
+        return pulumi.get(self, "site_id")
+
+    @property
+    @pulumi.getter(name="siteName")
+    def site_name(self) -> str:
+        """
+        Site Name
+        """
+        return pulumi.get(self, "site_name")
+
+    @property
+    @pulumi.getter
+    def status(self) -> str:
+        """
+        The status of the resource
+        """
+        return pulumi.get(self, "status")
+
+