@volcengine/pulumi-volcenginecc 0.0.44 → 0.0.46

package/types/input.d.ts

@@ -27,17 +27,17 @@ export interface ProviderEndpoints {
 export declare namespace alb {
     interface AclAclEntry {
         /**
-         * Description of the IP entry. Cannot start with http:// or https://. Must start with a letter or Chinese character. Can include numbers, English commas (,), periods (.), underscores (_), spaces, equals signs (=), hyphens (-), Chinese commas (，), and Chinese periods (。). Length must be between 1 and 255 characters. If not specified, defaults to an empty string.
+         * Description of the IP entry. Cannot start with http:// or https://. Must start with a letter or Chinese character. Can include numbers, English commas (,), periods (.), underscores (_), spaces ( ), equals signs (=), hyphens (-), Chinese commas (，), and Chinese periods (。). Length limit: 1–255 characters. If not specified, defaults to an empty string
          */
         description?: pulumi.Input<string>;
         /**
-         * IP entry address range. Only CIDR addresses are supported.
+         * IP entry address range; only CIDR addresses are supported
          */
         entry?: pulumi.Input<string>;
     }
     interface AclListener {
         /**
-         * Listener control mode for this access control policy group. white: allowlist mode; black: denylist mode
+         * Control mode of the listener for this access control policy group. white: Allowlist mode; black: Denylist mode
          */
         aclType?: pulumi.Input<string>;
         /**
@@ -59,11 +59,11 @@ export declare namespace alb {
     }
     interface AclTag {
         /**
-         * Tag key for user tags. Length must be between 1 and 128 characters. Case sensitive. Cannot start with any combination of volc: or sys: in any case. Cannot start or end with a space. Can include characters from any language, numbers, spaces, underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), minus signs (-), and @. Tag keys for the same resource must be unique.
+         * User tag key. Length limit: 1–128 characters. Case sensitive. Cannot start with any combination of volc: or sys: (case insensitive). Cannot start or end with a space. Supports characters from all languages, numbers, spaces (), underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), hyphens (-), and @. Tag keys for the same resource must be unique
          */
         key?: pulumi.Input<string>;
         /**
-         * User tag value. Length must be between 0 and 256 characters. Case sensitive. Cannot start or end with a space. Supports characters from all languages, numbers, spaces (), underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), hyphens (-), and @.
+         * User tag value. Length limit: 0–256 characters. Case sensitive. Cannot start or end with a space. Supports characters from all languages, numbers, spaces (), underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), hyphens (-), and @
          */
         value?: pulumi.Input<string>;
     }
@@ -117,7 +117,7 @@ export declare namespace alb {
     }
     interface ListenerDomainExtension {
         /**
-         * Server certificate ID used by the domain name. Effective when the certificate source is cert_center.
+         * Server certificate ID used by the domain. Effective when the certificate source is cert_center.
          */
         certCenterCertificateId?: pulumi.Input<string>;
         /**
@@ -125,11 +125,11 @@ export declare namespace alb {
          */
         certificateId?: pulumi.Input<string>;
         /**
-         * Source of the server certificate used by the domain. Values: alb: certificate uploaded via ALB. cert_center: SSL certificate purchased or uploaded via Volcano Engine Certificate Center.
+         * Source of the server certificate used by the domain. Values: alb: certificate uploaded via ALB. cert_center: SSL certificate purchased or uploaded through Volcano Engine Certificate Center.
          */
         certificateSource?: pulumi.Input<string>;
         /**
-         * Domain name. Usually cannot be empty. If the instance supports automatic selection of extension certificates (SniAutoMatch is on), Domain must be set to an empty string. Must contain at least one '.' and cannot start or end with '.'. Only lowercase letters, digits, '.', '-', and '*' are allowed. Length limit: 1–128 characters. Wildcard domain: use '*' to replace one or more characters. '*' must be at the beginning or end of the domain name. '*' cannot appear twice in the same domain name. No characters other than '.' can appear before or after '*'. Exact domain: an exact domain name that complies with domain name specifications. Domain names under the same HTTPS listener cannot be duplicated. Domain name matching is case-insensitive.
+         * Domain name. Usually cannot be empty. If the instance supports automatic selection of extended certificates (SniAutoMatch is on), Domain must be an empty string. Must contain at least one '.' and cannot start or end with '.'. Only lowercase letters, digits, '.', '-', and '*' are allowed. Length must be between 1 and 128 characters. Wildcard domain: use '*' to replace one or more characters. '*' must be at the beginning or end of the domain name. '*' cannot appear twice in the same domain name. No characters except '.' can be before or after '*'. Exact domain: a domain name that meets domain name specifications. Domain names under the same HTTPS listener cannot be duplicated. Domain matching is case-insensitive.
          */
         domain?: pulumi.Input<string>;
         /**
@@ -137,7 +137,7 @@ export declare namespace alb {
          */
         pcaLeafCertificateId?: pulumi.Input<string>;
         /**
-         * If the instance supports automatic selection of extension certificates, that is, when SniAutoMatch is set to on, Domain is an empty string. San refers to the certificate's extension domain names, separated by commas.
+         * If the instance supports automatic selection of extended certificates (SniAutoMatch is on), Domain is an empty string. San refers to the extended domain names of the certificate, separated by commas.
          */
         san?: pulumi.Input<string>;
     }
@@ -153,11 +153,11 @@ export declare namespace alb {
     }
     interface ListenerTag {
         /**
-         * User tag key. Rules: Length must be between 1 and 128 characters. Case sensitive. Cannot start with any case combination of volc:. Cannot start or end with a space. Allowed characters include all languages, numbers, spaces, parentheses (), underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), minus signs (-), and @. Tag keys for the same resource cannot be duplicated.
+         * Tag key for user tags. Rules are as follows: Length must be between 1 and 128 characters. Case sensitive. Cannot start with any case combination of volc:. Cannot start or end with a space. Can include characters from any language, numbers, spaces, underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), minus signs (-), and @. Tag keys for the same resource must be unique.
          */
         key?: pulumi.Input<string>;
         /**
-         * User tag value. Rules: Length must be between 0 and 256 characters. Case sensitive. Cannot start or end with a space. Allowed characters include all languages, numbers, spaces, parentheses (), underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), minus signs (-), and @.
+         * The value of the user tag. Rules: Length must be between 0 and 256 characters. Case sensitive. Cannot start or end with a space. May include characters from any language, numbers, spaces, underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), hyphens (-), and @.
          */
         value?: pulumi.Input<string>;
     }
@@ -482,31 +482,31 @@ export declare namespace alb {
     }
     interface ServerGroupHealthCheck {
         /**
-         * The domain name for health checks must be configured as the actual address used by the backend server to provide external services. This parameter is only effective when HealthCheck.Protocol is set to HTTP. The domain name must contain at least one '.', and cannot start or end with a '.'. Each level of the domain name can include letters, numbers, '-', and '.' characters, but '-' cannot appear at the beginning or end of any level. Length must be between 1 and 128 characters. If this parameter is not provided or no value is specified, it defaults to empty, meaning the load balancer uses the private IP address of each backend server for health checks.
+         * Domain name for health check. Configure this as the actual service address provided by the backend server. This parameter takes effect only when HealthCheck.Protocol is set to HTTP. The domain name must contain at least one '.', and cannot start or end with '.'. Each level of the domain name can contain letters, digits, '-', and '.' characters, and '-' cannot appear at the beginning or end of any level. Length: 1–128 characters. If this parameter is not specified or no value is provided, the default is empty, meaning the load balancer uses the private IP address of each backend server for health checks.
          */
         domain?: pulumi.Input<string>;
         /**
-         * Whether the listener has enabled health check. Values: on: enabled (default), off: disabled.
+         * Whether the listener enables health check. Values: on: enabled (default), off: disabled.
          */
         enabled?: pulumi.Input<string>;
         /**
-         * Health check threshold. Indicates that a backend server is considered healthy if it passes the specified number of consecutive health checks. Unit: checks. Range: 2–10. Default: 3.
+         * Health check threshold. Indicates the number of consecutive successful health checks required for a backend server to be considered healthy. Unit: times. Value range: 2–10. Default: 3.
          */
         healthyThreshold?: pulumi.Input<number>;
         /**
-         * HTTP status codes indicating a successful health check. Use commas to separate multiple codes. This parameter is only available when HealthCheck.Protocol is set to HTTP. Valid values: http*2xx (default), http*3xx (default), http*4xx, http*5xx.
+         * HTTP status codes for a successful health check. Separate multiple codes with commas. This parameter is available only when HealthCheck.Protocol is HTTP. Valid values: http*2xx (default), http*3xx (default), http*4xx, http*5xx.
          */
         httpCode?: pulumi.Input<string>;
         /**
-         * HTTP protocol version for health checks. This parameter is only available when HealthCheck.Protocol is set to HTTP. Values: HTTP1.0 (default when using API), HTTP1.1.
+         * Health check HTTP protocol version. This parameter is available only when HealthCheck.Protocol is set to HTTP. Values: HTTP1.0 (default for API usage), HTTP1.1.
          */
         httpVersion?: pulumi.Input<string>;
         /**
-         * After enabling health check, the interval for performing health checks. Unit: seconds. Range: 1–300s. Default: 2.
+         * After health checks are enabled, the interval for performing health checks. Unit: seconds. Value range: 1–300s. Default: 2.
          */
         interval?: pulumi.Input<number>;
         /**
-         * After enabling health check, the health check method. This parameter is effective only when HealthCheck.Protocol is set to HTTP. Values: GET: server must support the GET method. HEAD (default): server returns only HEAD header information, which can reduce backend performance consumption, but the server must support the HEAD method.
+         * Health check method after health checks are enabled. This parameter is valid only when HealthCheck.Protocol is set to HTTP. Values: GET: The server must support the GET method. HEAD (default): The server returns only the HEAD header, which reduces backend resource consumption, but the server must support the HEAD method.
          */
         method?: pulumi.Input<string>;
         /**
@@ -518,15 +518,15 @@ export declare namespace alb {
          */
         protocol?: pulumi.Input<string>;
         /**
-         * Health check response timeout. If the backend server does not respond correctly within the specified time, it is considered a health check failure. Unit: seconds; range: 1~60; default: 2.
+         * Health check response timeout. If the backend server does not respond correctly within the specified time, the health check is considered abnormal. Unit: seconds. Value range: 1–60. Default: 2.
          */
         timeout?: pulumi.Input<number>;
         /**
-         * Unhealthy threshold for health checks. If a backend server fails the specified number of consecutive health checks, it will be considered unhealthy. Unit: times. Value range: 2–10. Default: 3.
+         * Unhealthy threshold for health checks. Indicates that a backend server is considered unhealthy if it fails the specified number of consecutive health checks. Unit: times. Range: 2–10. Default: 3.
          */
         unhealthyThreshold?: pulumi.Input<number>;
         /**
-         * Health check path, which must be configured as the actual path provided by the backend server. This parameter is effective only when HealthCheck.Protocol is set to HTTP. Must start with '/'. Only letters, numbers, '-', '_', '/', '.', '%', '?', '#', '&', '=' are allowed. Length must be between 1 and 128 characters. If this parameter is not specified or no value is provided, the default is '/'.
+         * Health check path. Must be configured as the actual path provided by the backend server. This parameter is only effective when HealthCheck.Protocol is set to HTTP. Must start with '/'. Only letters, numbers, '-', '_', '/', '.', '%', '?', '#', '&', '=' are allowed. Length: 1–128 characters. If this parameter is not specified or specified without a value, the default is '/'.
          */
         uri?: pulumi.Input<string>;
     }
@@ -542,7 +542,7 @@ export declare namespace alb {
          */
         description?: pulumi.Input<string>;
         /**
-         * ID of the cloud server instance or network interface.
+         * ID of the cloud server instance or network interface card.
          */
         instanceId?: pulumi.Input<string>;
         /**
@@ -554,7 +554,7 @@ export declare namespace alb {
          */
         port?: pulumi.Input<number>;
         /**
-         * Enable remote IP feature. This field is valid when the backend server instance type is IP address, that is, when Type is set to ip. Values: on: enabled. off (default): disabled.
+         * Enable remote IP feature. This field is valid only when the backend server instance type is IP address, that is, when Type is set to ip. Parameter values: on: Enable. off (default): Disable.
          */
         remoteEnabled?: pulumi.Input<string>;
         /**
@@ -562,21 +562,21 @@ export declare namespace alb {
          */
         serverId?: pulumi.Input<string>;
         /**
-         * Backend server instance type. ECS: cloud server instance; ENI: secondary network interface; IP: IP address (only valid for IP-type server groups).
+         * Backend server instance type. ecs: ECS instance. eni: auxiliary ENI. ip: IP address (valid only for IP-type server groups).
          */
         type?: pulumi.Input<string>;
         /**
-         * Backend server weight.
+         * Weight of the backend server.
          */
         weight?: pulumi.Input<number>;
     }
     interface ServerGroupStickySessionConfig {
         /**
-         * Session persistence cookie name configured for the service. Only valid when session persistence is enabled and cookie rewrite is selected. Rules: Cookie name length must be 1–200 characters. The name can only contain ASCII letters and numbers, cannot include commas (,), semicolons (;), or spaces, and cannot start with a dollar sign ($). When stickySessionConfig.StickySessionEnabled is on and StickySessionConfig.StickySessionType is server, this parameter is required. When StickySessionConfig.StickySessionEnabled is on and StickySessionConfig.StickySessionType is insert, this parameter is invalid.
+         * Name of the session persistence Cookie for service configuration. This is only valid when session persistence is enabled and Cookie overwrite is selected. The specific rules are as follows: The Cookie name must be 1–200 characters long. The name can only contain ASCII letters and digits, cannot contain commas (,), semicolons (;), or spaces, and cannot start with a dollar sign ($). This parameter is required when tickySessionConfig.StickySessionEnabled is set to on and StickySessionConfig.StickySessionType is server. This parameter is invalid when StickySessionConfig.StickySessionEnabled is on and StickySessionConfig.StickySessionType is insert.
          */
         cookie?: pulumi.Input<string>;
         /**
-         * Session persistence cookie timeout. Only effective when session persistence is enabled and cookie insertion is selected. Unit: seconds. Rules: timeout range: 1~86400; default: 1000. This parameter is required when StickySessionConfig.StickySessionEnabled is on and StickySessionConfig.StickySessionType is insert. This parameter is invalid when StickySessionConfig.StickySessionEnabled is on and StickySessionType is server.
+         * Session persistence cookie timeout. Only valid when session persistence is enabled and the insert cookie option is selected. Unit: seconds. Rules: Timeout range: 1–86400. Default: 1000. This parameter is required when StickySessionConfig.StickySessionEnabled is on and StickySessionConfig.StickySessionType is insert. This parameter is invalid when StickySessionConfig.StickySessionEnabled is on and StickySessionType is server.
          */
         cookieTimeout?: pulumi.Input<number>;
         /**
@@ -584,17 +584,17 @@ export declare namespace alb {
          */
         stickySessionEnabled?: pulumi.Input<string>;
         /**
-         * Cookie handling method. When StickySessionConfig.StickySessionEnabled is set to on, this field is required. Values: insert: Insert a Cookie. ALB records the backend server to which the client's first request is forwarded. ALB inserts a Cookie in the response, and subsequent client requests carrying this Cookie are forwarded to the previously recorded backend server. server: Rewrite the Cookie. When session persistence with Cookie rewriting is enabled, after the client's first request is forwarded to the backend server, if ALB finds your custom Cookie in the response, it rewrites the original Cookie. Subsequent client requests carrying the rewritten Cookie are forwarded to the previously recorded backend server.
+         * Cookie handling method. This field is required when StickySessionConfig.StickySessionEnabled is set to on. Parameter values: insert: Inserts a Cookie. ALB records the backend server to which the client's first request is forwarded. ALB inserts a Cookie in the response. Subsequent client requests carry this Cookie, and ALB forwards the requests to the previously recorded backend server. server: Overwrites the Cookie. When session persistence with Cookie overwrite is enabled, after the client's first request is forwarded to the backend server, if ALB detects your custom Cookie in the response, it overwrites the original Cookie. Subsequent client requests carry the overwritten Cookie, and ALB forwards the requests to the previously recorded backend server.
          */
         stickySessionType?: pulumi.Input<string>;
     }
     interface ServerGroupTag {
         /**
-         * Tag key. Duplicate tag keys are not allowed for the same resource.
+         * Tag key. Tag keys for the same resource must be unique.
          */
         key?: pulumi.Input<string>;
         /**
-         * Tag value.
+         * Tag value of the tag.
          */
         value?: pulumi.Input<string>;
     }
@@ -4595,7 +4595,7 @@ export declare namespace cloudmonitor {
     }
     interface RuleDimensionConditionsMetaConditionMeta {
         /**
-         * Tag match operator. contain: Contains not*contain: Does not contain prefix*match: Prefix match suffix*match: Suffix match equal: Equals not*equal: Does not equal exist: Exists.
+         * Comparator for tag matching. contain: Contains. not*contain: Does not contain. prefix*match: Prefix match. suffix*match: Suffix match. equal: Equals. not*equal: Does not equal. exist: Exists.
          */
         comparator?: pulumi.Input<string>;
         /**
@@ -4622,7 +4622,7 @@ export declare namespace cloudmonitor {
     }
     interface RuleDimensionConditionsTagConditionTag {
         /**
-         * Tag match operator. contain: Contains not*contain: Does not contain prefix*match: Prefix match suffix*match: Suffix match equal: Equals not*equal: Does not equal exist: Exists.
+         * Comparator for tag matching. contain: Contains. not*contain: Does not contain. prefix*match: Prefix match. suffix*match: Suffix match. equal: Equals. not*equal: Does not equal. exist: Exists.
          */
         comparator?: pulumi.Input<string>;
         /**
@@ -4683,7 +4683,7 @@ export declare namespace cloudmonitor {
     }
     interface RuleNotifyTemplate {
         /**
-         * Notification channel. Options: email: Email sms: SMS phone: Phone feishu: Feishu dingtalk: DingTalk wecom: WeCom slack: Slack api: Callback URL.
+         * Notification channels. Values: email: Email, sms: SMS, phone: Phone, lark: Lark, dingtalk: DingTalk, wecom: WeCom, slack: Slack, api: Callback URL.
          */
         channel?: pulumi.Input<string>;
         /**
@@ -4724,43 +4724,59 @@ export declare namespace cr {
     interface RegistryEndpoint {
         aclPolicies?: pulumi.Input<pulumi.Input<inputs.cr.RegistryEndpointAclPolicy>[]>;
         /**
-         * Whether to enable the public endpoint. Options: false: not enabled; true: enabled. Default is false
+         * Whether to enable the public endpoint. Values: false: do not enable. true: enable. Default is false.
          */
         enabled?: pulumi.Input<boolean>;
         /**
-         * Current status of the public endpoint. Parameter values: Enabling: enabling; Enabled: enabled; Disabling: disabling; Updating: updating; Failed: failed; Disabled: disabled
+         * Current status of the public endpoint. Parameter values: Enabling: being enabled. Enabled: enabled. Disabling: being disabled. Updating: updating. Failed: failed. Disabled: disabled.
          */
         status?: pulumi.Input<string>;
     }
     interface RegistryEndpointAclPolicy {
         /**
-         * IP entry address
+         * IP entry address.
          */
         description?: pulumi.Input<string>;
         /**
-         * IP entry description
+         * IP entry description.
          */
         entry?: pulumi.Input<string>;
     }
     interface RegistryProxyCache {
         /**
-         * Instance types supported by ProxyCache. Parameter value description: DockerHub: DockerHub image repository.
+         * Instance types supported by ProxyCache for container registry. Parameter values are as follows: DockerHub: DockerHub container registry
          */
         type?: pulumi.Input<string>;
     }
     interface RegistryStatus {
         /**
-         * Creating, [ Progressing ]: Creating. Running, [ Ok ]: Running. Running, [ Degraded ]: Running. Stopped, [ Balance ]: Suspended due to overdue payment. Stopped, [ Released ]: Pending recycle. Stopped, [ Released, Balance ]: Suspended due to overdue payment. Starting, [ Progressing ]: Starting. Deleting, [ Progressing ]: Deleting. Failed, [ Unknown ]: Error.
+         * Creating, [ Progressing ]: Creating
+         * Running, [ Ok ]: Running
+         * Running, [ Degraded ]: Running
+         * Stopped, [ Balance ]: Suspended due to insufficient balance
+         * Stopped, [ Released ]: Pending reclamation
+         * Stopped, [ Released, Balance ]: Suspended due to insufficient balance
+         * Starting, [ Progressing ]: Starting
+         * Deleting, [ Progressing ]: Deleting
+         * Failed, [ Unknown ]: Abnormal
          */
         conditions?: pulumi.Input<pulumi.Input<string>[]>;
         /**
-         * Creating, [ Progressing ]: Creating. Running, [ Ok ]: Running. Running, [ Degraded ]: Running. Stopped, [ Balance ]: Suspended due to overdue payment. Stopped, [ Released ]: Pending recycle. Stopped, [ Released, Balance ]: Suspended due to overdue payment. Starting, [ Progressing ]: Starting. Deleting, [ Progressing ]: Deleting. Failed, [ Unknown ]: Error.
+         * Creating, [ Progressing ]: Creating
+         * Running, [ Ok ]: Running
+         * Running, [ Degraded ]: Running
+         * Stopped, [ Balance ]: Suspended due to insufficient balance
+         * Stopped, [ Released ]: Pending reclamation
+         * Stopped, [ Released, Balance ]: Suspended due to insufficient balance
+         * Starting, [ Progressing ]: Starting
+         * Deleting, [ Progressing ]: Deleting
+         * Failed, [ Unknown ]: Abnormal
          */
         phase?: pulumi.Input<string>;
     }
     interface RegistryTag {
         /**
-         * Tag key
+         * Tag key values
          */
         key?: pulumi.Input<string>;
         /**
@@ -4784,6 +4800,16 @@ export declare namespace cr {
     }
 }
 export declare namespace directconnect {
+    interface ConnectionTag {
+        /**
+         * Tag key. Cannot start with volc: or sys:. Length range: 1 ~ 128 characters
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Tag value. Length range: 0 ~ 256 characters. If not specified, defaults to empty
+         */
+        value?: pulumi.Input<string>;
+    }
     interface DirectConnectGatewayAssociateCen {
         /**
          * ID of CEN.
@@ -6863,6 +6889,68 @@ export declare namespace filenas {
     }
 }
 export declare namespace fwcenter {
+    interface AddressBookAddressDetailList {
+        /**
+         * Detailed information about the address in the address book. The specific content depends on the address book type. If GroupType is ip, enter an IPv4 address or CIDRv4; if ipv6, enter an IPv6 address or CIDRv6; if port, enter port information (a single port such as 22 or a port range such as 100/200); if domain, enter domain information.
+         */
+        address?: pulumi.Input<string>;
+        /**
+         * Detailed description of a single address in the address book, used to explain the specific purpose or other relevant information for that address.
+         */
+        description?: pulumi.Input<string>;
+    }
+    interface AddressBookTag {
+        /**
+         * Tag key.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Tag value.
+         */
+        value?: pulumi.Input<string>;
+    }
+    interface ControlPolicyDestPortListV1 {
+        /**
+         * Detailed address information.
+         */
+        address?: pulumi.Input<string>;
+        /**
+         * Description
+         */
+        description?: pulumi.Input<string>;
+        /**
+         * Address type. ip: IPv4; ipv6: IPv6; domain: domain name; port: port
+         */
+        type?: pulumi.Input<string>;
+    }
+    interface ControlPolicyDestinationCidrListV1 {
+        /**
+         * Detailed address information.
+         */
+        address?: pulumi.Input<string>;
+        /**
+         * Description
+         */
+        description?: pulumi.Input<string>;
+        /**
+         * Address type. ip: IPv4; ipv6: IPv6; domain: domain name; port: port
+         */
+        type?: pulumi.Input<string>;
+    }
+    interface ControlPolicySourceCidrListV1 {
+        /**
+         * Detailed address information.
+         */
+        address?: pulumi.Input<string>;
+        /**
+         * Description
+         */
+        description?: pulumi.Input<string>;
+        /**
+         * Address type. ip: IPv4; ipv6: IPv6; domain: domain name; port: port
+         */
+        type?: pulumi.Input<string>;
+    }
     interface DnsControlPolicyDomainListV1 {
         /**
          * Specific address information.
@@ -6887,8 +6975,204 @@ export declare namespace fwcenter {
          */
         vpcId?: pulumi.Input<string>;
     }
+    interface NatFireWallControlPolicyDestPortListV1 {
+        /**
+         * Specific address information.
+         */
+        address?: pulumi.Input<string>;
+        /**
+         * Description.
+         */
+        description?: pulumi.Input<string>;
+        /**
+         * Address type. ip: IPv4; ipv6: IPv6; domain: domain name; port: port.
+         */
+        type?: pulumi.Input<string>;
+    }
+    interface NatFireWallControlPolicyDestinationCidrListV1 {
+        /**
+         * Specific address information.
+         */
+        address?: pulumi.Input<string>;
+        /**
+         * Description.
+         */
+        description?: pulumi.Input<string>;
+        /**
+         * Address type. ip: IPv4; ipv6: IPv6; domain: domain name; port: port.
+         */
+        type?: pulumi.Input<string>;
+    }
+    interface NatFireWallControlPolicySourceCidrListV1 {
+        /**
+         * Specific address information.
+         */
+        address?: pulumi.Input<string>;
+        /**
+         * Description.
+         */
+        description?: pulumi.Input<string>;
+        /**
+         * Address type. ip: IPv4; ipv6: IPv6; domain: domain name; port: port.
+         */
+        type?: pulumi.Input<string>;
+    }
+    interface VpcFireWallAclRuleDestPortListV1 {
+        /**
+         * Detailed address information.
+         */
+        address?: pulumi.Input<string>;
+        /**
+         * Description.
+         */
+        description?: pulumi.Input<string>;
+        /**
+         * Address type. ip: IPv4; ipv6: IPv6; domain: domain name; port: port.
+         */
+        type?: pulumi.Input<string>;
+    }
+    interface VpcFireWallAclRuleDestinationCidrListV1 {
+        /**
+         * Detailed address information.
+         */
+        address?: pulumi.Input<string>;
+        /**
+         * Description.
+         */
+        description?: pulumi.Input<string>;
+        /**
+         * Address type. ip: IPv4; ipv6: IPv6; domain: domain name; port: port.
+         */
+        type?: pulumi.Input<string>;
+    }
+    interface VpcFireWallAclRuleSourceCidrListV1 {
+        /**
+         * Detailed address information.
+         */
+        address?: pulumi.Input<string>;
+        /**
+         * Description.
+         */
+        description?: pulumi.Input<string>;
+        /**
+         * Address type. ip: IPv4; ipv6: IPv6; domain: domain name; port: port.
+         */
+        type?: pulumi.Input<string>;
+    }
 }
 export declare namespace gtm {
+    interface GtmPolicy {
+        /**
+         * If the current address pool set is unavailable, does Cloud Scheduling GTM only trigger an alert notification without automatically switching to an available address pool? true: Cloud Scheduling GTM only triggers an alert notification. false: Cloud Scheduling GTM automatically switches to an available address pool.
+         */
+        alarmOnly?: pulumi.Input<boolean>;
+        /**
+         * Routing mode for intelligent routing policies. perf: Performance first. capacity: Capacity first. feedback: Load feedback.
+         */
+        perfMode?: pulumi.Input<string>;
+        /**
+         * Routing mode. The parameter values are: lb: Routes user traffic proportionally to different IDC data centers based on load balancing. geo: Routes user traffic to the nearest IDC data center on the same carrier line based on the user's geographic location and carrier. geo-lb (default): First routes user traffic to the nearest IDC data center access line on the same carrier based on the user's geographic location and carrier, then distributes user traffic proportionally to multiple IDC data centers based on load balancing.
+         */
+        routingMode?: pulumi.Input<string>;
+        /**
+         * Statistics for addresses associated with the scheduling policy.
+         */
+        statistics?: pulumi.Input<inputs.gtm.GtmPolicyStatistics>;
+        targets?: pulumi.Input<pulumi.Input<inputs.gtm.GtmPolicyTarget>[]>;
+    }
+    interface GtmPolicyStatistics {
+        /**
+         * Number of available addresses.
+         */
+        activeAddr?: pulumi.Input<number>;
+        /**
+         * Number of unavailable addresses.
+         */
+        inactiveAddr?: pulumi.Input<number>;
+    }
+    interface GtmPolicyTarget {
+        /**
+         * Target address pool ID.
+         */
+        poolId?: pulumi.Input<string>;
+    }
+    interface GtmProbe {
+        /**
+         * Recommended number of health check probe points.
+         */
+        advisedNodeCount?: pulumi.Input<number>;
+        /**
+         * Whether health check is disabled. true: disabled. false: enabled.
+         */
+        disable?: pulumi.Input<boolean>;
+        /**
+         * DNS record type for the health check.
+         */
+        dnsRecordType?: pulumi.Input<string>;
+        /**
+         * Threshold for the number of health check failures before a single target address is considered faulty. For example, if you set this parameter to 3, a target address will be marked as faulty after 3 consecutive health check failures. Default value: 3.
+         */
+        failedCount?: pulumi.Input<number>;
+        /**
+         * Full domain name of the health check target address. This parameter is only valid when the health check protocol is set to HTTP or HTTPS.
+         */
+        host?: pulumi.Input<string>;
+        /**
+         * HTTP request method. This parameter is only valid when the health check protocol is set to HTTP or HTTPS.
+         */
+        httpMethod?: pulumi.Input<string>;
+        httpUsabilityCodes?: pulumi.Input<pulumi.Input<inputs.gtm.GtmProbeHttpUsabilityCode>[]>;
+        /**
+         * Interval between each health check, in seconds.
+         */
+        interval?: pulumi.Input<number>;
+        /**
+         * Whether to manually configure health check probe points. true: Manually configure health check probe points. false: Use recommended health check probe points.
+         */
+        isManualNodes?: pulumi.Input<boolean>;
+        /**
+         * List of probe nodes used for health checks.
+         */
+        nodes?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * Number of packets sent. If you set this parameter to 10, each ping check sends 10 packets simultaneously. This parameter is only valid when the health check protocol is set to ping.
+         */
+        pingCount?: pulumi.Input<number>;
+        /**
+         * Packet loss rate. Unit: percent. If the packet loss rate exceeds this parameter value, the result is considered abnormal. For example, if this parameter is set to 10 and the packet loss rate during a health check is greater than 10, the result is considered abnormal. This parameter is only valid when the health check protocol is set to ping.
+         */
+        pingLossPercent?: pulumi.Input<number>;
+        /**
+         * Port of the health check target address. This parameter is only valid when the health check protocol is set to HTTP or HTTPS.
+         */
+        port?: pulumi.Input<number>;
+        /**
+         * Protocol used for health checks. ping: ICMP protocol. tcp: TCP protocol. http: HTTP protocol. https: HTTPS protocol.
+         */
+        protocol?: pulumi.Input<string>;
+        /**
+         * Timeout for establishing a single TCP connection. For example, if you set this parameter to 2 seconds, a TCP connection will be considered failed if it is not established within 2 seconds during a health check. This parameter is only valid when the health check protocol is set to tcp.
+         */
+        tcpConnTimeout?: pulumi.Input<number>;
+        /**
+         * Timeout for the health check task. Unit: seconds.
+         */
+        timeout?: pulumi.Input<number>;
+        /**
+         * Path part of the health check target address, starting with /. This parameter is only valid when the health check protocol is set to HTTP or HTTPS.
+         */
+        url?: pulumi.Input<string>;
+    }
+    interface GtmProbeHttpUsabilityCode {
+        /**
+         * List of HTTP status codes.
+         */
+        codes?: pulumi.Input<pulumi.Input<number>[]>;
+        /**
+         * Operator. interval: matches values within the range. include: matches specified values. exclude: matches values other than the specified ones.
+         */
+        operator?: pulumi.Input<string>;
+    }
     interface PolicyStatistics {
         /**
          * Number of available addresses
@@ -7378,6 +7662,55 @@ export declare namespace iam {
     }
 }
 export declare namespace id {
+    interface AuthConfigApiKeyAuthConfig {
+        /**
+         * ApiKey Value
+         */
+        apiKey?: pulumi.Input<string>;
+        apiKeyMetadatas?: pulumi.Input<pulumi.Input<inputs.id.AuthConfigApiKeyAuthConfigApiKeyMetadata>[]>;
+        /**
+         * ApiKey Name
+         */
+        apiKeyName?: pulumi.Input<string>;
+        /**
+         * Expiration Timestamp
+         */
+        expiryTimestamp?: pulumi.Input<number>;
+    }
+    interface AuthConfigApiKeyAuthConfigApiKeyMetadata {
+        /**
+         * Parameter Location
+         */
+        location?: pulumi.Input<string>;
+        /**
+         * Parameter Name
+         */
+        parameterName?: pulumi.Input<string>;
+    }
+    interface AuthConfigJwtAuthConfig {
+        /**
+         * Allowed Audience List
+         */
+        allowedAudiences?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * Allowed Client List
+         */
+        allowedClients?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * JWT Discovery URL。
+         */
+        discoveryUrl?: pulumi.Input<string>;
+    }
+    interface PermissionNamespaceTag {
+        /**
+         * Tag Key
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Tag Value
+         */
+        value?: pulumi.Input<string>;
+    }
     interface ServiceBackend {
         /**
          * Backend service domain name, for example api.example.com
@@ -7527,15 +7860,17 @@ export declare namespace id {
          */
         value?: pulumi.Input<string>;
     }
-}
-export declare namespace kafka {
-    interface AllowListAssociatedInstance {
+    interface UserPoolBrand {
         /**
-         * ID of the instance bound to the allowlist
+         * Brand logo URL
          */
-        instanceId?: pulumi.Input<string>;
+        logoUri?: pulumi.Input<string>;
+        /**
+         * Brand name
+         */
+        name?: pulumi.Input<string>;
     }
-    interface GroupTag {
+    interface UserPoolTag {
         /**
          * Tag key
          */
@@ -7545,17 +7880,45 @@ export declare namespace kafka {
          */
         value?: pulumi.Input<string>;
     }
-    interface InstanceChargeInfo {
-        /**
-         * Whether to automatically renew the subscription instance after expiration. true   - auto renewal; false (default)   - no auto renewal, instance will be stopped upon expiration.
-         */
-        autoRenew?: pulumi.Input<boolean>;
+    interface WorkloadPoolTag {
         /**
-         * Expiration time for the subscription instance.
+         * Tag key
          */
-        chargeExpireTime?: pulumi.Input<string>;
+        key?: pulumi.Input<string>;
         /**
-         * Instance billing start time.
+         * Tag value
+         */
+        value?: pulumi.Input<string>;
+    }
+}
+export declare namespace kafka {
+    interface AllowListAssociatedInstance {
+        /**
+         * ID of the instance bound to the allowlist
+         */
+        instanceId?: pulumi.Input<string>;
+    }
+    interface GroupTag {
+        /**
+         * Tag key
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Tag value
+         */
+        value?: pulumi.Input<string>;
+    }
+    interface InstanceChargeInfo {
+        /**
+         * Whether to automatically renew the subscription instance after expiration. true   - auto renewal; false (default)   - no auto renewal, instance will be stopped upon expiration.
+         */
+        autoRenew?: pulumi.Input<boolean>;
+        /**
+         * Expiration time for the subscription instance.
+         */
+        chargeExpireTime?: pulumi.Input<string>;
+        /**
+         * Instance billing start time.
          */
         chargeStartTime?: pulumi.Input<string>;
         /**
@@ -8978,6 +9341,10 @@ export declare namespace rdsmysql {
          * Whether to enable automatic scaling for the instance. Values: true: Yes. false: No.
          */
         enableStorageAutoScale?: pulumi.Input<boolean>;
+        /**
+         * Node range for automatic scaling detection. Values: MasterNode: primary node. MasterSlaveNodes: primary and secondary nodes. AllNodes: all nodes. Note: When used as a request parameter, the default is MasterNode. For multi-node instances, MasterSlaveNodes and AllNodes have the same effect. For single-node instances, MasterNode, MasterSlaveNodes, and AllNodes have the same effect.
+         */
+        scalingDetectNode?: pulumi.Input<string>;
         /**
          * Percentage of available storage space that triggers automatic scaling. Value range: 10–50, default: 10, unit: %
          */
@@ -8987,6 +9354,152 @@ export declare namespace rdsmysql {
          */
         storageUpperBound?: pulumi.Input<number>;
     }
+    interface InstanceBackupPolicy {
+        /**
+         * List of destination regions available for cross-region backup.
+         */
+        availableCrossRegions?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * Basic backup policy.
+         */
+        backupPolicyBase?: pulumi.Input<inputs.rdsmysql.InstanceBackupPolicyBackupPolicyBase>;
+        /**
+         * Cross-region backup policy.
+         */
+        crossBackupPolicy?: pulumi.Input<inputs.rdsmysql.InstanceBackupPolicyCrossBackupPolicy>;
+    }
+    interface InstanceBackupPolicyBackupPolicyBase {
+        /**
+         * Retain all log backups before releasing the instance. Values: true: yes. false: no.
+         */
+        binlogBackupAllRetention?: pulumi.Input<boolean>;
+        /**
+         * Enable log backup feature. Values: true: yes. false: no.
+         */
+        binlogBackupEnabled?: pulumi.Input<boolean>;
+        /**
+         * Whether to enable encryption for log backups. Values: true: Yes. false: No.
+         */
+        binlogBackupEncryptionEnabled?: pulumi.Input<boolean>;
+        /**
+         * Enable local Binlog retention limit. Values: true: enabled. false: disabled.
+         */
+        binlogFileCountsEnable?: pulumi.Input<boolean>;
+        /**
+         * Number of local Binlog files to retain, values range from 6 to 1000. Files exceeding the retention count are automatically deleted.
+         */
+        binlogLimitCount?: pulumi.Input<number>;
+        /**
+         * Local Binlog retention period. Value: 0–168. Unit: hours. Local logs exceeding the retention period are automatically deleted. When set to 0, local logs are not deleted automatically.
+         */
+        binlogLocalRetentionHour?: pulumi.Input<number>;
+        /**
+         * Enable automatic Binlog cleanup when storage is excessive. When total instance storage usage exceeds 80% or available space is less than 5 GiB, the system automatically deletes the oldest local Binlog files until usage drops below 80% and available space exceeds 5 GiB. true: enabled. false: disabled.
+         */
+        binlogSpaceLimitEnable?: pulumi.Input<boolean>;
+        /**
+         * Maximum storage space usage. Can be set to 20%–50%. When exceeded, the earliest Binlog files are automatically deleted until usage falls below this threshold. Note: Local Binlog space usage = local Binlog size / total available (purchased) instance space.
+         */
+        binlogStoragePercentage?: pulumi.Input<number>;
+        /**
+         * Retain all data backups before releasing the instance. Values: true: yes. false: no.
+         */
+        dataBackupAllRetention?: pulumi.Input<boolean>;
+        /**
+         * Enable encryption for data backups of local disk instances. Values: true: yes. false: no. Note: This feature is not supported for cloud disk instances.
+         */
+        dataBackupEncryptionEnabled?: pulumi.Input<boolean>;
+        /**
+         * Number of days to retain data backups. Valid values: 7–3650 days. Default: 7 days.
+         */
+        dataBackupRetentionDay?: pulumi.Input<number>;
+        /**
+         * Full backup cycle. Values: Monday: Monday. Tuesday: Tuesday. Wednesday: Wednesday. Thursday: Thursday. Friday: Friday. Saturday: Saturday. Sunday: Sunday.
+         */
+        dataFullBackupPeriods?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * Start time of the full backup task time window (UTC). The time window is 1 hour. Note: Both DataFullBackupStartUTCHour and DataFullBackupTime can be used to specify the full backup time period for the instance. DataFullBackupStartUTCHour has higher priority. If both fields are returned, DataFullBackupStartUTCHour takes precedence.
+         */
+        dataFullBackupStartUtcHour?: pulumi.Input<number>;
+        /**
+         * Time window for executing backup tasks, with a duration of 1 hour. Format: HH:mmZ-HH:mmZ (UTC). Note: Both DataFullBackupStartUTCHour and DataFullBackupTime can be used to specify the full backup time period for the instance. DataFullBackupStartUTCHour has higher priority. If both fields are returned, DataFullBackupStartUTCHour takes precedence.
+         */
+        dataFullBackupTime?: pulumi.Input<string>;
+        /**
+         * Incremental backup cycle for local disk instances. Values: Monday: Monday. Tuesday: Tuesday. Wednesday: Wednesday. Thursday: Thursday. Friday: Friday. Saturday: Saturday. Sunday: Sunday. Note: When high-frequency incremental backup is enabled (that is, when HourlyIncrBackupEnable is set to true), this field is not returned.
+         */
+        dataIncrBackupPeriods?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * Number of days to retain data after instance release.
+         */
+        dataKeepDaysAfterReleased?: pulumi.Input<number>;
+        /**
+         * Policy for retaining instance backups after the instance is released. Values: Last: retain the last backup (default). All: retain all backups of the instance.
+         */
+        dataKeepPolicyAfterReleased?: pulumi.Input<string>;
+        /**
+         * Whether high-frequency incremental snapshot backup is enabled for cloud disk instances. Values: true: Yes. false: No. Note: For local disk instances, this field returns false.
+         */
+        highFrequencySnapshotBackupEnable?: pulumi.Input<boolean>;
+        /**
+         * Frequency of high-frequency incremental snapshot backups for cloud disk instances, in seconds. Values: 3600: every 1 hour. 7200: every 2 hours. 10800: every 3 hours. 14400: every 4 hours. 19200: every 6 hours. 28800: every 8 hours. 38400: every 12 hours. Note: If the instance is a local disk instance or the high-frequency incremental snapshot backup feature for the cloud disk instance is not enabled, this field returns 0.
+         */
+        highFrequencySnapshotBackupSecondPeriod?: pulumi.Input<number>;
+        /**
+         * Whether to enable high-frequency backup for local disk instances. Values: true: Yes. false: No.
+         */
+        hourlyIncrBackupEnable?: pulumi.Input<boolean>;
+        /**
+         * Frequency of high-frequency incremental backups for local disk instances. Values: 0: no high-frequency incremental backup. In this case, HourlyIncrBackupEnable is false. 2: incremental backup every 2 hours. 4: incremental backup every 4 hours. 6: incremental backup every 6 hours. 12: incremental backup every 12 hours.
+         */
+        incrBackupHourPeriod?: pulumi.Input<number>;
+        /**
+         * Whether to retain cross-region backups. Values: true: Yes. false: No. Note: This feature is not supported for cloud disk instances.
+         */
+        keepCrossBackupEnableAfterReleased?: pulumi.Input<boolean>;
+        /**
+         * Maximum DDL wait time. Default value is 30, minimum is 10, maximum is 1440, in minutes.
+         */
+        lockDdlTime?: pulumi.Input<number>;
+        /**
+         * Maximum DDL wait time. Default value: 1800. Minimum: 1. Maximum: 86400. Unit: seconds. Note: The backup process will block DDL. If the blocking time exceeds the specified value, the backup will stop automatically. Only MySQL 8.0 instances support this setting.
+         */
+        lockDdlTimeSecond?: pulumi.Input<number>;
+        /**
+         * Binlog backup retention period. Value range: 7–3650 days. Default retention is 7 days. Note: This parameter is not returned when RetentionPolicySynced is set to true.
+         */
+        logBackupRetentionDay?: pulumi.Input<number>;
+        /**
+         * Whether to allow downloading instance backup data from a public network environment. Values: true: Yes. false: No.
+         */
+        publicDownloadEnable?: pulumi.Input<boolean>;
+        /**
+         * Whether the retention policy for log backups is the same as that for data backups. Values: true: Yes. false: No.
+         */
+        retentionPolicySynced?: pulumi.Input<boolean>;
+    }
+    interface InstanceBackupPolicyCrossBackupPolicy {
+        /**
+         * Enable cross-region backup. true: enabled. false: disabled. Default value (unspecified).
+         */
+        backupEnabled?: pulumi.Input<boolean>;
+        /**
+         * Retain cross-region backups long-term before instance release. Values: true: yes. false: no.
+         */
+        crossBackupAllRetention?: pulumi.Input<boolean>;
+        /**
+         * Destination region ID for cross-region backups. This parameter is required when BackupEnabled is true.
+         */
+        crossBackupRegion?: pulumi.Input<string>;
+        /**
+         * Whether to enable cross-region log backup. true: Enable. false: Disable (default). Note: Cross-region log backup can only be enabled when cross-region backup is enabled.
+         */
+        logBackupEnabled?: pulumi.Input<boolean>;
+        /**
+         * Cross-region backup retention days. Value range: 7–3650. Default: 7. Unit: days. Note: When CrossBackupAllRetention is set to true, this field does not need to be set.
+         */
+        retention?: pulumi.Input<number>;
+    }
     interface InstanceChargeDetail {
         /**
          * Enable auto-renewal for prepaid scenarios. Values: true: auto-renewal. false: do not auto-renew
@@ -9064,6 +9577,7 @@ export declare namespace rdsmysql {
         secondsBehindMaster?: pulumi.Input<number>;
     }
     interface InstanceEndpoint {
+        addresses?: pulumi.Input<pulumi.Input<inputs.rdsmysql.InstanceEndpointAddress>[]>;
         /**
          * When the endpoint type is read/write or read-only, you can set whether new nodes join automatically. Values: Enable: auto join. Disable: do not auto join (default)
          */
@@ -9080,6 +9594,7 @@ export declare namespace rdsmysql {
          * Connection pool type for proxy terminal. Values: Transaction: Transaction-level connection pool. Default value. Direct: Direct mode.
          */
         connectionPoolType?: pulumi.Input<string>;
+        customRouteStrategies?: pulumi.Input<pulumi.Input<inputs.rdsmysql.InstanceEndpointCustomRouteStrategy>[]>;
         /**
          * Description of the connection endpoint
          */
@@ -9146,6 +9661,54 @@ export declare namespace rdsmysql {
          */
         readWriteMode?: pulumi.Input<string>;
     }
+    interface InstanceEndpointAddress {
+        /**
+         * false: Private network resolution (default). true: Private and public network resolution.
+         */
+        dnsVisibility?: pulumi.Input<boolean>;
+        /**
+         * Connection domain name.
+         */
+        domain?: pulumi.Input<string>;
+        /**
+         * EIP ID, valid only for Public addresses.
+         */
+        eipId?: pulumi.Input<string>;
+        /**
+         * Whether the EIP used by the connected terminal is suspended due to overdue payment. Values: true: Yes. false: No.
+         */
+        eipLocked?: pulumi.Input<boolean>;
+        /**
+         * IP protocol version. Value: IPv4.
+         */
+        internetProtocol?: pulumi.Input<string>;
+        /**
+         * IP address.
+         */
+        ipAddress?: pulumi.Input<string>;
+        /**
+         * Network address type. Values: Private: private address. Public: public address.
+         */
+        networkType?: pulumi.Input<string>;
+        /**
+         * Port.
+         */
+        port?: pulumi.Input<string>;
+        /**
+         * Subnet ID, valid only for Private addresses.
+         */
+        subnetId?: pulumi.Input<string>;
+    }
+    interface InstanceEndpointCustomRouteStrategy {
+        /**
+         * SQL forwarding rule target. Values: Primary: primary node. Secondary: secondary node. ReadOnly: read-only node. Note: For dual-node instances, you can select the primary node or read-only node. For multi-node instances, you can select the primary node or secondary node.
+         */
+        nodeType?: pulumi.Input<string>;
+        /**
+         * Forwarding rule keywords. SQL keyword setting rules are as follows: Each rule can contain up to 20 keywords. Maximum length is 64 characters. Can include English letters, numbers, underscores (_), @, #, :=, and Chinese characters.
+         */
+        sqlKeyword?: pulumi.Input<string>;
+    }
     interface InstanceEndpointReadOnlyNodeWeight {
         /**
          * Read-only nodes require NodeId. Primary nodes do not require it
@@ -9761,6 +10324,44 @@ export declare namespace redis {
          */
         securityGroupId?: pulumi.Input<string>;
     }
+    interface InstanceBackup {
+        /**
+         * Backup point ID
+         */
+        backupPointId?: pulumi.Input<string>;
+        /**
+         * Backup point name
+         */
+        backupPointName?: pulumi.Input<string>;
+        /**
+         * Backup policy
+         */
+        backupStrategy?: pulumi.Input<string>;
+        /**
+         * Backup type
+         */
+        backupType?: pulumi.Input<string>;
+        /**
+         * Backup end time
+         */
+        endTime?: pulumi.Input<string>;
+        /**
+         * Instance ID
+         */
+        instanceId?: pulumi.Input<string>;
+        /**
+         * Backup size (unit: Byte)
+         */
+        size?: pulumi.Input<number>;
+        /**
+         * Backup start time
+         */
+        startTime?: pulumi.Input<string>;
+        /**
+         * Backup status
+         */
+        status?: pulumi.Input<string>;
+    }
     interface InstanceBackupRestore {
         /**
          * Backup ID, used to specify which backup to use when restoring from a backup set
@@ -10522,6 +11123,16 @@ export declare namespace tls {
          */
         severity?: pulumi.Input<string>;
     }
+    interface AlarmWebhookIntegrationTypeWebhookHeader {
+        /**
+         * Key for custom request header
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Value for custom request header
+         */
+        value?: pulumi.Input<string>;
+    }
     interface EtlTargetResource {
         /**
          * Name of the custom output target. You must use this name to refer to the output target in the data processing rules
@@ -12542,6 +13153,74 @@ export declare namespace tos {
          */
         value?: pulumi.Input<string>;
     }
+    interface BucketWebsiteErrorDocument {
+        /**
+         * When a 4xx error occurs, this page is returned
+         */
+        key?: pulumi.Input<string>;
+    }
+    interface BucketWebsiteIndexDocument {
+        /**
+         * Whether to support redirecting to the default homepage of a subdirectory. Value description: false (default): Does not support redirecting to the default homepage of a subdirectory. true: Supports redirecting to the default homepage of a subdirectory
+         */
+        forbiddenSubDir?: pulumi.Input<boolean>;
+        /**
+         * When requesting a directory (ending with /), returns the object specified by Suffix in that directory. For example, if Suffix is set to index.html, accessing document/ returns document/index.html
+         */
+        suffix?: pulumi.Input<string>;
+    }
+    interface BucketWebsiteRedirectAllRequestsTo {
+        /**
+         * Redirect site name
+         */
+        hostName?: pulumi.Input<string>;
+        /**
+         * Protocol used for redirect requests. Supports http and https. Default is http
+         */
+        protocol?: pulumi.Input<string>;
+    }
+    interface BucketWebsiteRoutingRule {
+        /**
+         * Set the matching conditions for the redirect rule. The redirect rule only takes effect when all specified conditions are met
+         */
+        condition?: pulumi.Input<inputs.tos.BucketWebsiteRoutingRuleCondition>;
+        /**
+         * Set redirect rule
+         */
+        redirect?: pulumi.Input<inputs.tos.BucketWebsiteRoutingRuleRedirect>;
+    }
+    interface BucketWebsiteRoutingRuleCondition {
+        /**
+         * Set the HTTP error code that triggers the redirect rule. For example, if HttpErrorCodeReturnedEquals is set to 404, the rule takes effect when the specified object does not exist. If KeyPrefixEquals is set, the redirect rule only takes effect when both HttpErrorCodeReturnedEquals and KeyPrefixEquals conditions are met
+         */
+        httpErrorCodeReturnedEquals?: pulumi.Input<number>;
+        /**
+         * Set the object name prefix for the redirect rule to take effect. If HttpErrorCodeReturnedEquals is set, the redirect rule only takes effect when both HttpErrorCodeReturnedEquals and KeyPrefixEquals conditions are met
+         */
+        keyPrefixEquals?: pulumi.Input<string>;
+    }
+    interface BucketWebsiteRoutingRuleRedirect {
+        /**
+         * Set the redirect site name
+         */
+        hostName?: pulumi.Input<string>;
+        /**
+         * Status code returned during redirect. Only 3XX status codes can be set; 300 cannot be set. Default is 301
+         */
+        httpRedirectCode?: pulumi.Input<number>;
+        /**
+         * Protocol used for redirect requests, including http and https. Default is http
+         */
+        protocol?: pulumi.Input<string>;
+        /**
+         * Object name prefix used for redirect
+         */
+        replaceKeyPrefixWith?: pulumi.Input<string>;
+        /**
+         * Object name used for redirect
+         */
+        replaceKeyWith?: pulumi.Input<string>;
+    }
 }
 export declare namespace transitrouter {
     interface DirectConnectGatewayAttachmentTag {
@@ -12983,6 +13662,373 @@ export declare namespace vedbm {
         value?: pulumi.Input<string>;
     }
 }
+export declare namespace veenedge {
+    interface CloudServerAdvancedConfiguration {
+        /**
+         * Enable deletion protection.
+         */
+        deleteProtection?: pulumi.Input<boolean>;
+        /**
+         * Description of the edge instance. Up to 80 characters allowed. When you create edge instances in batches, the system adds the same description to each instance.
+         */
+        instanceDesc?: pulumi.Input<string>;
+        /**
+         * Custom hostname. Naming rules: Windows systems allow 2–10 characters. Supports lowercase letters, numbers, and hyphens (-). Cannot contain only numbers. Cannot start or end with a hyphen (-), and hyphens (-) cannot be used consecutively. Linux systems allow 2–59 characters. Supports lowercase letters, numbers, and hyphens (-). Cannot start or end with a hyphen (-), and hyphens (-) cannot be used consecutively. When creating edge instances in bulk, the system adds a numeric suffix to your custom hostname. Example: \n\n-1, \n\n-2.
+         */
+        instanceHostName?: pulumi.Input<string>;
+        /**
+         * Edge instance name. Naming rules: 5–80 characters allowed. Supports Chinese, uppercase letters, lowercase letters, and numbers. Supports special characters ()`~!@#$%^&*-+=_|{}[]:;'<>,.?/. Spaces are not allowed, and the name cannot start with a forward slash (/). When creating edge instances in batch, the system will add a numeric suffix to the specified instance name. Example: \n\n-1, \n\n-2.
+         */
+        instanceName?: pulumi.Input<string>;
+    }
+    interface CloudServerBillingConfig {
+        /**
+         * Enable auto-renewal. This parameter is effective only when computing*billing*method is set to PrePaid. Value options: true: Enable auto-renewal. false (default): Disable auto-renewal.
+         */
+        autoRenew?: pulumi.Input<boolean>;
+        /**
+         * Bandwidth billing method. Value options: MonthlyP95: Billed by monthly 95th percentile. DailyPeak: Billed by daily peak. If you require daily peak billing or other billing methods, please submit a ticket.
+         */
+        bandwidthBillingMethod?: pulumi.Input<string>;
+        /**
+         * Computing billing method. Value range: MonthlyPeak: Billed by monthly peak. DailyPeak: Billed by daily peak. PrePaid: Yearly/monthly subscription. When computing*billing*method is set to PrePaid, you must also specify the pre*paid*period and pre*paid*period_number parameters.
+         */
+        computingBillingMethod?: pulumi.Input<string>;
+        /**
+         * Unit for the purchase duration of the resource. When the value of computing*billing*method is PrePaid, this parameter must be specified. Value range: monthly: month.
+         */
+        prePaidPeriod?: pulumi.Input<string>;
+        /**
+         * Resource purchase duration. When computing*billing*method is set to PrePaid, this parameter must be specified. Valid values: 1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 24, 36.
+         */
+        prePaidPeriodNumber?: pulumi.Input<number>;
+    }
+    interface CloudServerCustomData {
+        /**
+         * Custom data. Custom data is configuration information for edge instances. You can enter up to 16KB of custom data. Input requirements: Scripts must be entered in plain text. The platform will automatically encode the script in Base64. Do not enter scripts that are already Base64 encoded. For Linux systems, use Shell scripts, which typically start with #!/bin/bash. For Windows systems, use PowerShell scripts, which can be entered directly. The script will execute when the edge instance starts for the first time. If the operating system of the edge instance is reset or replaced later, the script will also execute the first time the system starts after the reset or replacement.
+         */
+        data?: pulumi.Input<string>;
+    }
+    interface CloudServerInstanceAreaNum {
+        /**
+         * Region name
+         */
+        areaName?: pulumi.Input<string>;
+        /**
+         * Node name. Specify the node where you want to deploy the edge service.
+         */
+        clusterName?: pulumi.Input<string>;
+        /**
+         * Default ISP. This parameter applies only to multi-line nodes. When specifying the default ISP, ensure it is within the node ISP range. Only one ISP can be set as the default. Note: When the value of external*network*mode is single*interface*cmcc*ip, single*interface*cucc*ip, or single*interface*ctcc*ip, the ISP specified in default*isp must match the ISP specified in external*network*mode. For example, when external*network*mode is single*interface*cmcc*ip, the value of default*isp must be set to CMCC. When external*network*mode is single*interface*multi*ip or multi*interface*multi*ip, the default*isp parameter must be specified, and the value can be set to CMCC, CUCC, or CTCC as needed. When external*network*mode is single*interface*single*ip or no*interface, default*isp does not need to be specified.
+         */
+        defaultIsp?: pulumi.Input<string>;
+        /**
+         * Public network configuration. This parameter applies only to multi-line nodes. Value options: single*interface*multi*ip: Single NIC, multiple IPs. If you are a new multi-line node user, submit a ticket to enable the relevant permissions. single*interface*cmcc*ip: Single NIC, CMCC IP. Submit a ticket to enable the relevant permissions. single*interface*cucc*ip: Single NIC, CUCC IP. Submit a ticket to enable the relevant permissions. single*interface*ctcc*ip: Single NIC, CTCC IP. Submit a ticket to enable the relevant permissions. multi*interface*multi*ip: Multiple NICs, multiple IPs. Submit a ticket to enable the relevant permissions. single*interface*single*ip: Single NIC, single IP. In this mode, the system randomly assigns a public IP address from an available carrier based on inventory. no*interface: No public NIC. Submit a ticket to enable the relevant permissions. Default value: When a public NIC is present: If single NIC multi-IP permission is enabled, single*interface*multi*ip (Single NIC, multiple IPs) is used by default. If single NIC multi-IP permission is disabled, single*interface*single*ip (Single NIC, single IP) is used by default. If no public NIC is present, no*interface is used by default.
+         */
+        externalNetworkMode?: pulumi.Input<string>;
+        /**
+         * List of hostnames. The system assigns hostnames to created edge instances in order. You can use both the host*name*list and instance*host*name parameters at the same time. Both parameters take effect, but host*name*list has higher priority than instance*host*name. For example, if you create 3 edge instances in bulk, set instance*host*name to host, and set host*name*list to "hosta","hostb", then the names of the 3 edge instances will be hosta, hostb, and host-3 respectively.
+         */
+        hostNameLists?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * Carrier. Possible values: CMCC, CTCC, CUCC.
+         */
+        isp?: pulumi.Input<string>;
+        /**
+         * Network interface names for private network type edge instances configured with multiple public network interfaces. You can use this parameter to set the names of public and private network interfaces. Please note the following when using this parameter: Usage restrictions: This parameter is only applicable to private network type edge instances. You must submit a ticket to enable the relevant feature before this parameter can be used; otherwise, the parameter value is invalid. Effectiveness: If you set the interface name using the custom*internal*interface*name or custom*external*interface*name parameter in the network*config structure, and also set the interface name using the multi*interface*name*config parameter, only the latter will take effect. If you set the public network interface name only through the custom*external*interface*name parameter in the network*config structure, the name cannot be eth2, eth3, Ethernet2, or Ethernet3. The name you set will be used as the name for the Telecom public network interface. The names for the Unicom and Mobile public network interfaces will use the default values. If you do not set the interface name, the default values will be used: Linux edge instances: The default name for the private network interface is eth0. The default name for the Telecom public network interface is eth1. The default name for the Unicom public network interface is eth2. The default name for the Mobile public network interface is eth3. Windows edge instances: The default name for the private network interface is Ethernet0. The default name for the Telecom public network interface is Ethernet1. The default name for the Unicom public network interface is Ethernet2. The default name for the Mobile public network interface is Ethernet3. Notes: The multi*interface*name*config parameter and the single*interface*name*config parameter cannot be specified at the same time. The names of different network interfaces on the same edge instance must be unique. When using the multi*interface*name*config parameter, you must specify all interface names at the same time.
+         */
+        multiInterfaceNameConfig?: pulumi.Input<inputs.veenedge.CloudServerInstanceAreaNumMultiInterfaceNameConfig>;
+        /**
+         * Number of instances.
+         */
+        num?: pulumi.Input<number>;
+        /**
+         * Network interface card name for a private network type edge instance configured with a single public network interface card. You can use this parameter to set the names of the public and private network interface cards. It is recommended to set both the public and private network interface card names. Please note the following when using this parameter: Usage restrictions: This parameter is only applicable to private network type edge instances. You must submit a ticket to enable the relevant feature before this parameter can be used; otherwise, the parameter value is invalid. Effectiveness: If you set the network interface card name using the custom*internal*interface*name or custom*external*interface*name parameters in the network*config structure, and also set the name using the single*interface*name*config parameter, only the latter will take effect. If you do not set the network interface card name, the default values will be used: For Linux edge instances: the private network interface card name defaults to eth0, and the public network interface card name defaults to eth1. For Windows edge instances: the private network interface card name defaults to Ethernet0, and the public network interface card name defaults to Ethernet1. Notes: The single*interface*name*config parameter and the multi*interface*name*config parameter cannot be specified at the same time. The names of different network interface cards within the same edge instance must be unique. This parameter applies to edge instances with a single public network interface card on both single-line and multi-line nodes, but does not apply to edge instances with multiple public network interface cards on multi-line nodes.
+         */
+        singleInterfaceNameConfig?: pulumi.Input<inputs.veenedge.CloudServerInstanceAreaNumSingleInterfaceNameConfig>;
+        /**
+         * Subnet ID. If you specify a custom private network, you must also set subnetIdentity to specify the subnet.
+         */
+        subnetIdentity?: pulumi.Input<string>;
+        /**
+         * Private network ID. This parameter specifies the private network where the edge service is deployed. If vpc*identity is set, cluster*name must also be set. If you specify a custom private network, you must also set subnetIdentity to specify the subnet.
+         */
+        vpcIdentity?: pulumi.Input<string>;
+    }
+    interface CloudServerInstanceAreaNumMultiInterfaceNameConfig {
+        /**
+         * Mobile public network interface name. Naming rules: 3–15 characters allowed. Uppercase and lowercase letters, numbers, hyphens (-), and underscores (_) are permitted. Interface names must be unique within the same edge instance.
+         */
+        cmccExternalInterfaceName?: pulumi.Input<string>;
+        /**
+         * Telecom public network interface name. Naming rules: 3–15 characters allowed. Uppercase and lowercase letters, numbers, hyphens (-), and underscores (_) are allowed. The network interface name must be unique within the same edge instance.
+         */
+        ctccExternalInterfaceName?: pulumi.Input<string>;
+        /**
+         * Public network NIC name. Naming rules: 3–15 characters allowed. Uppercase and lowercase letters, numbers, hyphens (-), and underscores (_) are permitted. NIC names must be unique within the same edge instance.
+         */
+        cuccExternalInterfaceName?: pulumi.Input<string>;
+        /**
+         * Private network interface name. Naming rules: 3–15 characters allowed. Uppercase and lowercase letters, numbers, hyphens (-), and underscores (_) are permitted. Network interface names must be unique within the same edge instance.
+         */
+        internalInterfaceName?: pulumi.Input<string>;
+    }
+    interface CloudServerInstanceAreaNumSingleInterfaceNameConfig {
+        /**
+         * Public network interface name. Naming rules: 3–15 characters allowed. Uppercase and lowercase letters, numbers, hyphens (-), and underscores (_) are allowed. The network interface name must be unique within the same edge instance.
+         */
+        externalInterfaceName?: pulumi.Input<string>;
+        /**
+         * Private network interface name. Naming rules: 3–15 characters allowed. Uppercase and lowercase letters, numbers, hyphens (-), and underscores (_) are permitted. Network interface names must be unique within the same edge instance.
+         */
+        internalInterfaceName?: pulumi.Input<string>;
+    }
+    interface CloudServerNetworkConfig {
+        /**
+         * Peak public bandwidth. Value range: [5, maximum bandwidth supported by the instance type]. Value must be a multiple of 5. Unit: Mbps. When you select an IPv4/IPv6 dual-stack edge instance, the configured peak bandwidth is shared by the IPv4 and IPv6 public IP addresses. If disable*ipv4 is set to true, you do not need to configure the bandwidth*peak parameter.
+         */
+        bandwidthPeak?: pulumi.Input<string>;
+        bandwidthPeakLimitIspConfigs?: pulumi.Input<pulumi.Input<inputs.veenedge.CloudServerNetworkConfigBandwidthPeakLimitIspConfig>[]>;
+        /**
+         * Shared public bandwidth peak for all elastic public IPs bound to the private IP address of the edge instance. Private IP addresses include both primary and secondary private IP addresses. The value range for this parameter is the same as the bandwidthPeak parameter. When you set a shared bandwidth peak, the bandwidth peak of the elastic public IP itself will not take effect.
+         */
+        boundEipShareBandwidthPeak?: pulumi.Input<string>;
+        /**
+         * Name of the public network interface. Naming rules: 3–15 characters allowed. Uppercase and lowercase letters, numbers, hyphens (-), and underscores (_) are allowed. The network interface name must be unique within the same edge instance.
+         */
+        customExternalInterfaceName?: pulumi.Input<string>;
+        /**
+         * Private network NIC name. Naming rules: 3–15 characters allowed. Uppercase and lowercase letters, numbers, hyphens (-), and underscores (_) are permitted. NIC names must be unique within the same edge instance.
+         */
+        customInternalInterfaceName?: pulumi.Input<string>;
+        /**
+         * Whether to disable IPv4. Value range: true: Disable IPv4. false (default): Enable IPv4.
+         */
+        disableIpv4?: pulumi.Input<boolean>;
+        /**
+         * DNS list. The first IP address is the primary DNS, and the subsequent IP addresses are backup DNS.
+         */
+        dnsLists?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * DNS type: default: Default DNS. custom: Custom DNS. If this parameter is not set, the default DNS configuration is used, with the preferred DNS as 114.114.114.114 and the alternate DNS as 180.184.1.1. DNS configuration is not supported for bare metal instances. When the instance type is bare metal, you do not need to set the dns*type and dns*list parameters.
+         */
+        dnsType?: pulumi.Input<string>;
+        /**
+         * Enable IPv6. Value options: true: Enable IPv6. false (default): Disable IPv6. By default, the system assigns a public IPv4 address to the edge instance. When IPv6 is enabled, the system assigns both a public IPv4 address and a public IPv6 address to the edge instance.
+         */
+        enableIpv6?: pulumi.Input<boolean>;
+        /**
+         * Rate limiting mode. When using multi-line nodes, you can configure the rate limiting mode for edge instances. Value options: shared (default): Shared rate limiting. All carriers share bandwidth resources, and the total public bandwidth used does not exceed the bandwidthPeak value (public bandwidth peak). isp: Carrier-based rate limiting. You can set the bandwidth peak for each carrier individually.
+         */
+        limitMode?: pulumi.Input<string>;
+        /**
+         * Number of auxiliary private IPs.
+         */
+        secondaryInternalIpNum?: pulumi.Input<number>;
+        /**
+         * List of bound global firewall IDs.
+         */
+        securityGroupIdLists?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * TCP connection timeout for edge instances. If no data is transmitted over an established TCP connection and this condition lasts for the configured timeout period, the edge instance will close the connection. Value range: 30~910. Default: 900. Unit: seconds. All edge instances created under edge services use the currently configured TCP connection timeout. If you modify this setting, newly created edge instances will use the updated configuration; existing edge instances are not affected.
+         */
+        tcpTimeout?: pulumi.Input<number>;
+        /**
+         * UDP session timeout for edge instances. If no data is transmitted in an established UDP session and the duration reaches the configured timeout, the edge instance will clear the session state information. Value range: 15~310. Default: 60. Unit: seconds. All edge instances created under the edge service use the currently configured UDP session timeout. If you modify this configuration, new edge instances will use the updated configuration; existing edge instances are not affected.
+         */
+        udpTimeout?: pulumi.Input<number>;
+    }
+    interface CloudServerNetworkConfigBandwidthPeakLimitIspConfig {
+        /**
+         * Bandwidth limit value for this carrier.
+         */
+        bandwidthPeakLimit?: pulumi.Input<string>;
+        /**
+         * Carrier. Value options: CMCC: China Mobile. CTCC: China Telecom. CUCC: China Unicom.
+         */
+        isp?: pulumi.Input<string>;
+    }
+    interface CloudServerScheduleStrategy {
+        /**
+         * Pricing policy: high*priority: prioritize higher price. When you create multiple edge instances across multiple regions, this policy means the system will prioritize nodes in cities with higher bandwidth prices for deploying edge instances. low*priority: prioritize lower price. When you create multiple edge instances across multiple regions, this policy means the system will prioritize nodes in cities with lower bandwidth prices for deploying edge instances.
+         */
+        priceStrategy?: pulumi.Input<string>;
+        /**
+         * Scheduling policy: dispersion: city dispersion. When you create multiple edge instances in multiple regions, this policy means the system prioritizes nodes in different cities for deploying edge instances. concentration: city concentration. When you create multiple edge instances in multiple regions, this policy means the system prioritizes nodes in the same city for deploying edge instances.
+         */
+        scheduleStrategy?: pulumi.Input<string>;
+    }
+    interface CloudServerSecretConfig {
+        /**
+         * Login password. Custom password: Password input rules are as follows: 8–30 characters allowed. The password must contain at least three of the following types: uppercase letters, lowercase letters, numbers, and special characters. Supported special characters: ()`~!@#$%^&*-+=_|{}[]:;'<>,.?/ Double quotes (") , backslash (), and spaces are not allowed, and the password cannot start with a forward slash (/). SSH Key type password: Enter the SSH key pair ID. You can query the key pair ID via the ListSSHKey API.
+         */
+        secretData?: pulumi.Input<string>;
+        /**
+         * Type of login password for edge instances. Value options: 2: Custom password. 3: SSH Key type password. 4: Indicates no login credentials are injected.
+         */
+        secretType?: pulumi.Input<number>;
+    }
+    interface CloudServerStorageConfig {
+        /**
+         * Data disk. This parameter is used to add a single data disk. To add multiple data disks at once, use the data*disk*list parameter.
+         */
+        dataDisk?: pulumi.Input<inputs.veenedge.CloudServerStorageConfigDataDisk>;
+        dataDiskLists?: pulumi.Input<pulumi.Input<inputs.veenedge.CloudServerStorageConfigDataDiskList>[]>;
+        dataLocalDisks?: pulumi.Input<pulumi.Input<inputs.veenedge.CloudServerStorageConfigDataLocalDisk>[]>;
+        /**
+         * System disk configuration
+         */
+        systemDisk?: pulumi.Input<inputs.veenedge.CloudServerStorageConfigSystemDisk>;
+    }
+    interface CloudServerStorageConfigDataDisk {
+        /**
+         * Disk capacity. Unit: GB. Capacity range: System cloud disk: 40–100. Data cloud disk: 20–1000.
+         */
+        capacity?: pulumi.Input<string>;
+        /**
+         * Release disk with instance
+         */
+        deleteWithInstance?: pulumi.Input<boolean>;
+        /**
+         * Disk unique identifier
+         */
+        diskIdentity?: pulumi.Input<string>;
+        /**
+         * Local disk type.
+         */
+        localDiskClass?: pulumi.Input<string>;
+        /**
+         * Local disk resource name.
+         */
+        localDiskResourceName?: pulumi.Input<string>;
+        /**
+         * Disk type. Valid values: CloudBlockHDD: HDD cloud disk. CloudBlockSSD: SSD cloud disk.
+         */
+        storageType?: pulumi.Input<string>;
+    }
+    interface CloudServerStorageConfigDataDiskList {
+        /**
+         * Disk capacity. Unit: GB. Capacity range: System cloud disk: 40–100. Data cloud disk: 20–1000.
+         */
+        capacity?: pulumi.Input<string>;
+        /**
+         * Release disk with instance
+         */
+        deleteWithInstance?: pulumi.Input<boolean>;
+        /**
+         * Disk unique identifier
+         */
+        diskIdentity?: pulumi.Input<string>;
+        /**
+         * Local disk type.
+         */
+        localDiskClass?: pulumi.Input<string>;
+        /**
+         * Local disk resource name.
+         */
+        localDiskResourceName?: pulumi.Input<string>;
+        /**
+         * Disk type. Valid values: CloudBlockHDD: HDD cloud disk. CloudBlockSSD: SSD cloud disk.
+         */
+        storageType?: pulumi.Input<string>;
+    }
+    interface CloudServerStorageConfigDataLocalDisk {
+        /**
+         * Disk specifications.
+         */
+        diskSpec?: pulumi.Input<inputs.veenedge.CloudServerStorageConfigDataLocalDiskDiskSpec>;
+        /**
+         * Number of disks
+         */
+        num?: pulumi.Input<number>;
+    }
+    interface CloudServerStorageConfigDataLocalDiskDiskSpec {
+        /**
+         * Disk capacity. Unit: GB. Capacity range: System cloud disk: 40–100. Data cloud disk: 20–1000.
+         */
+        capacity?: pulumi.Input<string>;
+        /**
+         * Release disk with instance
+         */
+        deleteWithInstance?: pulumi.Input<boolean>;
+        /**
+         * Disk unique identifier
+         */
+        diskIdentity?: pulumi.Input<string>;
+        /**
+         * Local disk type.
+         */
+        localDiskClass?: pulumi.Input<string>;
+        /**
+         * Local disk resource name.
+         */
+        localDiskResourceName?: pulumi.Input<string>;
+        /**
+         * Disk type. Valid values: CloudBlockHDD: HDD cloud disk. CloudBlockSSD: SSD cloud disk.
+         */
+        storageType?: pulumi.Input<string>;
+    }
+    interface CloudServerStorageConfigSystemDisk {
+        /**
+         * Disk capacity. Unit: GB. Capacity range: System cloud disk: 40–100. Data cloud disk: 20–1000.
+         */
+        capacity?: pulumi.Input<string>;
+        /**
+         * Release disk with instance
+         */
+        deleteWithInstance?: pulumi.Input<boolean>;
+        /**
+         * Disk unique identifier
+         */
+        diskIdentity?: pulumi.Input<string>;
+        /**
+         * Local disk type.
+         */
+        localDiskClass?: pulumi.Input<string>;
+        /**
+         * Local disk resource name.
+         */
+        localDiskResourceName?: pulumi.Input<string>;
+        /**
+         * Disk type. Valid values: CloudBlockHDD: HDD cloud disk. CloudBlockSSD: SSD cloud disk.
+         */
+        storageType?: pulumi.Input<string>;
+    }
+    interface CloudServerTag {
+        /**
+         * Tag key
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Tag value
+         */
+        value?: pulumi.Input<string>;
+    }
+    interface VpcSubnet {
+        /**
+         * Subnet CIDR Block, e.g. 10.1.0.0/16
+         */
+        cidr?: pulumi.Input<string>;
+        /**
+         * Subnet Description
+         */
+        desc?: pulumi.Input<string>;
+        /**
+         * Subnet Name
+         */
+        name?: pulumi.Input<string>;
+    }
+    interface VpcTag {
+        /**
+         * Tag Key
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Tag Value
+         */
+        value?: pulumi.Input<string>;
+    }
+}
 export declare namespace vefaas {
     interface FunctionAsyncTaskConfig {
         /**
@@ -15792,4 +16838,18 @@ export declare namespace waf {
          */
         statisticalKeyLists?: pulumi.Input<pulumi.Input<string>[]>;
     }
+    interface HostGroupRelatedRule {
+        /**
+         * Rule name.
+         */
+        ruleName?: pulumi.Input<string>;
+        /**
+         * Rule ID.
+         */
+        ruleTag?: pulumi.Input<string>;
+        /**
+         * Rule type. Allow indicates an allowlist, Block indicates a blocklist.
+         */
+        ruleType?: pulumi.Input<string>;
+    }
 }