@volcengine/pulumi-volcenginecc 0.0.43 → 0.0.45

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>;
         /**
@@ -4768,8 +4784,32 @@ export declare namespace cr {
          */
         value?: pulumi.Input<string>;
     }
+    interface VpcEndpointVpc {
+        /**
+         * Primary account ID for the VPC
+         */
+        accountId?: pulumi.Input<number>;
+        /**
+         * Subnet ID
+         */
+        subnetId?: pulumi.Input<string>;
+        /**
+         * VPC ID。
+         */
+        vpcId?: pulumi.Input<string>;
+    }
 }
 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.
@@ -6849,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.
@@ -6873,8 +6975,178 @@ export declare namespace fwcenter {
          */
         vpcId?: 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
+         */
+        activeAddr?: pulumi.Input<number>;
+        /**
+         * Number of unavailable addresses
+         */
+        inactiveAddr?: pulumi.Input<number>;
+    }
+    interface PolicyTarget {
+        /**
+         * Address pool ID.
+         */
+        poolId?: pulumi.Input<string>;
+    }
     interface PoolAddress {
         /**
          * Address capacity
@@ -7505,6 +7777,16 @@ export declare namespace kafka {
          */
         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.
@@ -8763,32 +9045,12 @@ export declare namespace rdsmysql {
          * Instance ID bound to the current allowlist.
          */
         instanceId?: pulumi.Input<string>;
-        /**
-         * Instance name bound to the current allowlist.
-         */
-        instanceName?: pulumi.Input<string>;
-        /**
-         * Instance status.
-         */
-        instanceStatus?: pulumi.Input<string>;
-        /**
-         * Has the latest allowlist been synchronized? Values: true: Yes. false: No. Note: When modifying the allowlist, if the instance is not running, changes to the allowlist will not be immediately synchronized to the instance.
-         */
-        isLatest?: pulumi.Input<boolean>;
-        /**
-         * Private network ID of the instance.
-         */
-        vpc?: pulumi.Input<string>;
     }
     interface AllowListSecurityGroupBindInfo {
         /**
          * Mode for associating security groups. Values: IngressDirectionIp: Inbound IP. AssociateEcsIp: Associate ECS IP. Note: In the CreateAllowList API, the BindMode and SecurityGroupId fields of SecurityGroupBindInfoObject are required.
          */
         bindMode?: pulumi.Input<string>;
-        /**
-         * Security group IP address list.
-         */
-        ipLists?: pulumi.Input<pulumi.Input<string>[]>;
         /**
          * Security group ID.
          */
@@ -8958,6 +9220,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: %
          */
@@ -8967,83 +9233,230 @@ export declare namespace rdsmysql {
          */
         storageUpperBound?: pulumi.Input<number>;
     }
-    interface InstanceChargeDetail {
+    interface InstanceBackupPolicy {
         /**
-         * Enable auto-renewal for prepaid scenarios. Values: true: auto-renewal. false: do not auto-renew
+         * List of destination regions available for cross-region backup.
          */
-        autoRenew?: pulumi.Input<boolean>;
+        availableCrossRegions?: pulumi.Input<pulumi.Input<string>[]>;
         /**
-         * Billing end time for subscription instance (UTC). Format: yyyy-MM-ddTHH:mm:ss.sssZ.
+         * Basic backup policy.
          */
-        chargeEndTime?: pulumi.Input<string>;
+        backupPolicyBase?: pulumi.Input<inputs.rdsmysql.InstanceBackupPolicyBackupPolicyBase>;
         /**
-         * Billing start time for the instance (UTC). Format: yyyy-MM-ddTHH:mm:ss.sssZ
+         * Cross-region backup policy.
          */
-        chargeStartTime?: pulumi.Input<string>;
+        crossBackupPolicy?: pulumi.Input<inputs.rdsmysql.InstanceBackupPolicyCrossBackupPolicy>;
+    }
+    interface InstanceBackupPolicyBackupPolicyBase {
         /**
-         * Instance billing status. Values: Normal: normal. Overdue: overdue. Unpaid: pending payment.
+         * Retain all log backups before releasing the instance. Values: true: yes. false: no.
          */
-        chargeStatus?: pulumi.Input<string>;
+        binlogBackupAllRetention?: pulumi.Input<boolean>;
         /**
-         * Billing type. Options: PrePaid: subscription. PostPaid: pay-as-you-go
+         * Enable log backup feature. Values: true: yes. false: no.
          */
-        chargeType: pulumi.Input<string>;
+        binlogBackupEnabled?: pulumi.Input<boolean>;
         /**
-         * Number of instances to purchase. Value range: 1–50. Default: 1
+         * Whether to enable encryption for log backups. Values: true: Yes. false: No.
          */
-        number?: pulumi.Input<number>;
+        binlogBackupEncryptionEnabled?: pulumi.Input<boolean>;
         /**
-         * Estimated release time after the instance is stopped due to overdue payment (pay-as-you-go) or expiration (subscription), in UTC. Format: yyyy-MM-ddTHH:mm:ss.sssZ
+         * Enable local Binlog retention limit. Values: true: enabled. false: disabled.
          */
-        overdueReclaimTime?: pulumi.Input<string>;
+        binlogFileCountsEnable?: pulumi.Input<boolean>;
         /**
-         * Time when the instance is stopped due to overdue payment (pay-as-you-go) or expiration (subscription) (UTC). Format: yyyy-MM-ddTHH:mm:ss.sssZ.
+         * Number of local Binlog files to retain, values range from 6 to 1000. Files exceeding the retention count are automatically deleted.
          */
-        overdueTime?: pulumi.Input<string>;
+        binlogLimitCount?: pulumi.Input<number>;
         /**
-         * Purchase duration in prepaid scenarios.
+         * 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.
          */
-        period?: pulumi.Input<number>;
+        binlogLocalRetentionHour?: pulumi.Input<number>;
         /**
-         * Purchase cycle in prepaid scenarios. Month: monthly purchase cycle (default). Year: yearly purchase cycle.
+         * 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.
          */
-        periodUnit?: pulumi.Input<string>;
+        binlogSpaceLimitEnable?: pulumi.Input<boolean>;
         /**
-         * Restore time for temporary scaling (UTC). Format: yyyy-MM-ddTHH:mm:ss.sssZ.
+         * 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.
          */
-        tempModifyEndTime?: pulumi.Input<string>;
+        binlogStoragePercentage?: pulumi.Input<number>;
         /**
-         * Start time for temporary scaling (UTC). Format: yyyy-MM-ddTHH:mm:ss.sssZ
+         * Retain all data backups before releasing the instance. Values: true: yes. false: no.
          */
-        tempModifyStartTime?: pulumi.Input<string>;
-    }
-    interface InstanceDisasterRecoveryInstance {
+        dataBackupAllRetention?: pulumi.Input<boolean>;
         /**
-         * ID of synchronization tasks between primary and disaster recovery instances.
+         * Enable encryption for data backups of local disk instances. Values: true: yes. false: no. Note: This feature is not supported for cloud disk instances.
          */
-        dtsTaskId?: pulumi.Input<string>;
+        dataBackupEncryptionEnabled?: pulumi.Input<boolean>;
         /**
-         * Name of the synchronization task between the primary instance and the disaster recovery instance
+         * Number of days to retain data backups. Valid values: 7–3650 days. Default: 7 days.
          */
-        dtsTaskName?: pulumi.Input<string>;
+        dataBackupRetentionDay?: pulumi.Input<number>;
         /**
-         * Status of synchronization tasks between the primary instance and the disaster recovery instance
+         * Full backup cycle. Values: Monday: Monday. Tuesday: Tuesday. Wednesday: Wednesday. Thursday: Thursday. Friday: Friday. Saturday: Saturday. Sunday: Sunday.
          */
-        dtsTaskStatus?: pulumi.Input<string>;
+        dataFullBackupPeriods?: pulumi.Input<pulumi.Input<string>[]>;
         /**
-         * Disaster recovery instance ID.
+         * 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.
          */
-        instanceId?: pulumi.Input<string>;
+        dataFullBackupStartUtcHour?: pulumi.Input<number>;
         /**
-         * Name of disaster recovery instance.
+         * 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.
          */
-        instanceName?: pulumi.Input<string>;
+        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
+         */
+        autoRenew?: pulumi.Input<boolean>;
+        /**
+         * Billing end time for subscription instance (UTC). Format: yyyy-MM-ddTHH:mm:ss.sssZ.
+         */
+        chargeEndTime?: pulumi.Input<string>;
+        /**
+         * Billing start time for the instance (UTC). Format: yyyy-MM-ddTHH:mm:ss.sssZ
+         */
+        chargeStartTime?: pulumi.Input<string>;
+        /**
+         * Instance billing status. Values: Normal: normal. Overdue: overdue. Unpaid: pending payment.
+         */
+        chargeStatus?: pulumi.Input<string>;
+        /**
+         * Billing type. Options: PrePaid: subscription. PostPaid: pay-as-you-go
+         */
+        chargeType: pulumi.Input<string>;
+        /**
+         * Number of instances to purchase. Value range: 1–50. Default: 1
+         */
+        number?: pulumi.Input<number>;
+        /**
+         * Estimated release time after the instance is stopped due to overdue payment (pay-as-you-go) or expiration (subscription), in UTC. Format: yyyy-MM-ddTHH:mm:ss.sssZ
+         */
+        overdueReclaimTime?: pulumi.Input<string>;
+        /**
+         * Time when the instance is stopped due to overdue payment (pay-as-you-go) or expiration (subscription) (UTC). Format: yyyy-MM-ddTHH:mm:ss.sssZ.
+         */
+        overdueTime?: pulumi.Input<string>;
+        /**
+         * Purchase duration in prepaid scenarios.
+         */
+        period?: pulumi.Input<number>;
+        /**
+         * Purchase cycle in prepaid scenarios. Month: monthly purchase cycle (default). Year: yearly purchase cycle.
+         */
+        periodUnit?: pulumi.Input<string>;
+        /**
+         * Restore time for temporary scaling (UTC). Format: yyyy-MM-ddTHH:mm:ss.sssZ.
+         */
+        tempModifyEndTime?: pulumi.Input<string>;
+        /**
+         * Start time for temporary scaling (UTC). Format: yyyy-MM-ddTHH:mm:ss.sssZ
+         */
+        tempModifyStartTime?: pulumi.Input<string>;
+    }
+    interface InstanceDisasterRecoveryInstance {
+        /**
+         * ID of synchronization tasks between primary and disaster recovery instances.
+         */
+        dtsTaskId?: pulumi.Input<string>;
+        /**
+         * Name of the synchronization task between the primary instance and the disaster recovery instance
+         */
+        dtsTaskName?: pulumi.Input<string>;
+        /**
+         * Status of synchronization tasks between the primary instance and the disaster recovery instance
+         */
+        dtsTaskStatus?: pulumi.Input<string>;
+        /**
+         * Disaster recovery instance ID.
+         */
+        instanceId?: pulumi.Input<string>;
+        /**
+         * Name of disaster recovery instance.
+         */
+        instanceName?: pulumi.Input<string>;
         /**
          * Latency between the disaster recovery instance and the primary instance.
          */
         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)
          */
@@ -9060,6 +9473,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
          */
@@ -9126,6 +9540,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
@@ -9741,6 +10203,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
@@ -9878,6 +10378,16 @@ export declare namespace redis {
     }
 }
 export declare namespace rocketmq {
+    interface AccessKeyTopicPermission {
+        /**
+         * Permission type. AccessKey has permissions for this Topic. ALL: Publish and subscribe permissions. PUB: Publish permission. SUB: Subscribe permission. DENY: No publish or subscribe permissions
+         */
+        permission?: pulumi.Input<string>;
+        /**
+         * Topic name
+         */
+        topicName?: pulumi.Input<string>;
+    }
     interface AllowListAssociatedInstance {
         /**
          * Instance ID
@@ -10462,35 +10972,489 @@ export declare namespace tls {
          */
         cronTab?: pulumi.Input<string>;
         /**
-         * Time zone in which the Cron expression takes effect.
+         * Time zone in which the Cron expression takes effect.
+         */
+        cronTimeZone?: pulumi.Input<string>;
+        /**
+         * Scheduling cycle or the specific time point for periodic execution (minutes from 00:00). Value range: 1–1440, in minutes.
+         */
+        time?: pulumi.Input<number>;
+        /**
+         * Scheduling interval type. Options: Period: schedule at regular intervals. Fixed: schedule at a fixed time each day. Cron: use a Cron expression.
+         */
+        type?: pulumi.Input<string>;
+    }
+    interface AlarmTriggerCondition {
+        /**
+         * Alert trigger condition expression.
+         */
+        condition?: pulumi.Input<string>;
+        /**
+         * Numerical expression for scenarios with data or specific entries, implemented using **count**.
+         */
+        countCondition?: pulumi.Input<string>;
+        /**
+         * When enabled, if the result after set operations is an empty set, a separate no-data alert is triggered.
+         */
+        noData?: pulumi.Input<boolean>;
+        /**
+         * Alert notification level, indicating the severity of the alert. Supports notice, warning, or critical, with severity increasing in that order. The default is notice.
+         */
+        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
+         */
+        alias: pulumi.Input<string>;
+        /**
+         * Region of the log topic for storing processed logs
+         */
+        region: pulumi.Input<string>;
+        /**
+         * Cross-account authorization role name
+         */
+        roleTrn?: pulumi.Input<string>;
+        /**
+         * Log topic ID for storing processed logs
+         */
+        topicId: pulumi.Input<string>;
+    }
+    interface HostGroupRule {
+        /**
+         * Container collection rules
+         */
+        containerRule?: pulumi.Input<inputs.tls.HostGroupRuleContainerRule>;
+        /**
+         * Time when the collection configuration was created.
+         */
+        createTime?: pulumi.Input<string>;
+        excludePaths?: pulumi.Input<pulumi.Input<inputs.tls.HostGroupRuleExcludePath>[]>;
+        /**
+         * Extraction rules
+         */
+        extractRule?: pulumi.Input<inputs.tls.HostGroupRuleExtractRule>;
+        /**
+         * Collection type. 0: Host log file. 1: K8s container standard output. 2: Log file inside K8s container.
+         */
+        inputType?: pulumi.Input<number>;
+        /**
+         * Log sample.
+         */
+        logSample?: pulumi.Input<string>;
+        /**
+         * Collection modes. minimalist*log: single-line full mode. json*log: JSON mode. delimiter*log: delimiter mode. multiline*log: multi-line full mode. fullregex_log: full regex mode.
+         */
+        logType?: pulumi.Input<string>;
+        /**
+         * Time when the collection configuration was modified.
+         */
+        modifyTime?: pulumi.Input<string>;
+        /**
+         * Data collection path list
+         */
+        paths?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * Running status of the collection configuration. 0: Running. 1: Paused.
+         */
+        pause?: pulumi.Input<number>;
+        /**
+         * Collection configuration ID.
+         */
+        ruleId?: pulumi.Input<string>;
+        /**
+         * Name of the collection configuration.
+         */
+        ruleName?: pulumi.Input<string>;
+        /**
+         * ID of the log topic to which the collection configuration belongs.
+         */
+        topicId?: pulumi.Input<string>;
+        /**
+         * Name of the log topic associated with the collection configuration
+         */
+        topicName?: pulumi.Input<string>;
+        /**
+         * User-defined collection rules.
+         */
+        userDefineRule?: pulumi.Input<inputs.tls.HostGroupRuleUserDefineRule>;
+    }
+    interface HostGroupRuleContainerRule {
+        /**
+         * Container name to collect. If no container name is specified, all containers in the machine group are collected. Supports regular expressions. For example, setting the container name to ^(container-test)$ collects all containers named container-test.
+         */
+        containerNameRegex?: pulumi.Input<string>;
+        envTags?: pulumi.Input<pulumi.Input<inputs.tls.HostGroupRuleContainerRuleEnvTag>[]>;
+        excludeContainerEnvRegexes?: pulumi.Input<pulumi.Input<inputs.tls.HostGroupRuleContainerRuleExcludeContainerEnvRegex>[]>;
+        excludeContainerLabelRegexes?: pulumi.Input<pulumi.Input<inputs.tls.HostGroupRuleContainerRuleExcludeContainerLabelRegex>[]>;
+        includeContainerEnvRegexes?: pulumi.Input<pulumi.Input<inputs.tls.HostGroupRuleContainerRuleIncludeContainerEnvRegex>[]>;
+        includeContainerLabelRegexes?: pulumi.Input<pulumi.Input<inputs.tls.HostGroupRuleContainerRuleIncludeContainerLabelRegex>[]>;
+        /**
+         * Kubernetes container collection rules.
+         */
+        kubernetesRule?: pulumi.Input<inputs.tls.HostGroupRuleContainerRuleKubernetesRule>;
+        /**
+         * Collection information. stdout: Container standard output (stdout). stderr: Container standard error (stderr). all: Both container standard output (stdout) and standard error (stderr).
+         */
+        stream?: pulumi.Input<string>;
+    }
+    interface HostGroupRuleContainerRuleEnvTag {
+        /**
+         * Key.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Value.
+         */
+        val?: pulumi.Input<string>;
+    }
+    interface HostGroupRuleContainerRuleExcludeContainerEnvRegex {
+        /**
+         * Key.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Value.
+         */
+        val?: pulumi.Input<string>;
+    }
+    interface HostGroupRuleContainerRuleExcludeContainerLabelRegex {
+        /**
+         * Key.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Value.
+         */
+        val?: pulumi.Input<string>;
+    }
+    interface HostGroupRuleContainerRuleIncludeContainerEnvRegex {
+        /**
+         * Key.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Value.
+         */
+        val?: pulumi.Input<string>;
+    }
+    interface HostGroupRuleContainerRuleIncludeContainerLabelRegex {
+        /**
+         * Key.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Value.
+         */
+        val?: pulumi.Input<string>;
+    }
+    interface HostGroupRuleContainerRuleKubernetesRule {
+        annotationTags?: pulumi.Input<pulumi.Input<inputs.tls.HostGroupRuleContainerRuleKubernetesRuleAnnotationTag>[]>;
+        /**
+         * Whether to add all Kubernetes Labels as log tags to the raw log data. When enabled, the log service adds fields for all Labels in the Kubernetes Pod to the log. For example, if the Pod has Label source=DC and destination=CS, the log will include fields **tag**source__: DC and **tag**destination__: CS.
+         */
+        enableAllLabelTag?: pulumi.Input<boolean>;
+        excludePodAnnotationRegexes?: pulumi.Input<pulumi.Input<inputs.tls.HostGroupRuleContainerRuleKubernetesRuleExcludePodAnnotationRegex>[]>;
+        excludePodLabelRegexes?: pulumi.Input<pulumi.Input<inputs.tls.HostGroupRuleContainerRuleKubernetesRuleExcludePodLabelRegex>[]>;
+        includePodAnnotationRegexes?: pulumi.Input<pulumi.Input<inputs.tls.HostGroupRuleContainerRuleKubernetesRuleIncludePodAnnotationRegex>[]>;
+        includePodLabelRegexes?: pulumi.Input<pulumi.Input<inputs.tls.HostGroupRuleContainerRuleKubernetesRuleIncludePodLabelRegex>[]>;
+        labelTags?: pulumi.Input<pulumi.Input<inputs.tls.HostGroupRuleContainerRuleKubernetesRuleLabelTag>[]>;
+        /**
+         * Name of the Kubernetes Namespace to be collected. If not specified, all containers are collected. Namespace names support regular expression matching. For example, setting the Namespace name to ^(tcp|udp)$ collects all containers under the tcp and udp namespaces.
+         */
+        namespaceNameRegex?: pulumi.Input<string>;
+        /**
+         * Pod name is used to specify the Pod(s) to be collected. If the Pod name is not specified, all containers are collected. Pod name supports regex matching. For example, setting the Pod name to ^(http.*)$ collects all containers under Pods whose names start with http.
+         */
+        podNameRegex?: pulumi.Input<string>;
+        /**
+         * Specify the container to collect by workload name. If no workload name is specified, all containers are collected. Workload names support regular expressions. For example, setting the workload name to ^(http.*)$ collects all containers under workloads starting with http.
+         */
+        workloadNameRegex?: pulumi.Input<string>;
+        /**
+         * Specify containers to collect by workload type. Only one type can be selected. If no type is specified, containers of all types will be collected. Supported workload types are: Deployment: stateless workload StatefulSet: stateful workload DaemonSet: daemon process Job: job CronJob: scheduled job
+         */
+        workloadType?: pulumi.Input<string>;
+    }
+    interface HostGroupRuleContainerRuleKubernetesRuleAnnotationTag {
+        /**
+         * Key.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Value.
+         */
+        val?: pulumi.Input<string>;
+    }
+    interface HostGroupRuleContainerRuleKubernetesRuleExcludePodAnnotationRegex {
+        /**
+         * Key.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Value.
+         */
+        val?: pulumi.Input<string>;
+    }
+    interface HostGroupRuleContainerRuleKubernetesRuleExcludePodLabelRegex {
+        /**
+         * Key.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Value.
+         */
+        val?: pulumi.Input<string>;
+    }
+    interface HostGroupRuleContainerRuleKubernetesRuleIncludePodAnnotationRegex {
+        /**
+         * Key.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Value.
+         */
+        val?: pulumi.Input<string>;
+    }
+    interface HostGroupRuleContainerRuleKubernetesRuleIncludePodLabelRegex {
+        /**
+         * Key.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Value.
+         */
+        val?: pulumi.Input<string>;
+    }
+    interface HostGroupRuleContainerRuleKubernetesRuleLabelTag {
+        /**
+         * Key.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Value.
+         */
+        val?: pulumi.Input<string>;
+    }
+    interface HostGroupRuleExcludePath {
+        /**
+         * Collection path type. File: file name. Path: directory.
+         */
+        type?: pulumi.Input<string>;
+        /**
+         * Collection path. Must be specified as an absolute path. When Type is Path, Value indicates a directory. When Type is File, Value indicates a file name.
+         */
+        value?: pulumi.Input<string>;
+    }
+    interface HostGroupRuleExtractRule {
+        /**
+         * The regex pattern required to match the first line of the log. This is valid only when LogType is multiline*log or fullregex*log. The pattern must be a valid regular expression.
+         */
+        beginRegex?: pulumi.Input<string>;
+        /**
+         * Log delimiter. Valid only when LogType is delimiter_log.
+         */
+        delimiter?: pulumi.Input<string>;
+        /**
+         * Enable nanosecond precision time. When enabled, log time parsing will report time with nanosecond precision. true: Enable nanosecond precision time. false: Disable nanosecond precision time.
+         */
+        enableNanosecond?: pulumi.Input<boolean>;
+        filterKeyRegexes?: pulumi.Input<pulumi.Input<inputs.tls.HostGroupRuleExtractRuleFilterKeyRegex>[]>;
+        /**
+         * List of log field names (Keys).
+         */
+        keys?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * The entire log entry must match the regular expression. This is only valid when the log type is fullregex_log. The regular expression must be valid.
+         */
+        logRegex?: pulumi.Input<string>;
+        /**
+         * Automatically extract log fields based on the specified log template.
+         */
+        logTemplate?: pulumi.Input<inputs.tls.HostGroupRuleExtractRuleLogTemplate>;
+        /**
+         * Quotation mark. Content enclosed by quotation marks is parsed as a complete field and not separated. Only valid when LogType is delimiter_log.
+         */
+        quote?: pulumi.Input<string>;
+        /**
+         * Regular expression for extracting time, used to extract the time value from the TimeKey field and parse it as the collection time.
+         */
+        timeExtractRegex?: pulumi.Input<string>;
+        /**
+         * Parsing format for the time field. If a specified time field in the log is used as the log timestamp, you must provide TimeKey and TimeFormat.
+         */
+        timeFormat?: pulumi.Input<string>;
+        /**
+         * Field name for the log time field. If a specified time field in the log is used as the log timestamp, you must provide TimeKey and TimeFormat.
+         */
+        timeKey?: pulumi.Input<string>;
+        /**
+         * Sample time. Used to verify whether the specified time parsing format is correct.
+         */
+        timeSample?: pulumi.Input<string>;
+        /**
+         * Time zone. Supports machine time zone (default) and custom time zone. Custom time zone supports GMT and UTC.
+         */
+        timeZone?: pulumi.Input<string>;
+        /**
+         * Key name for logs that failed to parse when uploading
+         */
+        unMatchLogKey?: pulumi.Input<string>;
+        /**
+         * Upload logs that failed to parse. UnMatchUpLoadSwitch=true and UnMatchLogKey must be used together. true: Upload logs that failed to parse. false: Do not upload logs that failed to parse.
+         */
+        unMatchUpLoadSwitch?: pulumi.Input<boolean>;
+    }
+    interface HostGroupRuleExtractRuleFilterKeyRegex {
+        /**
+         * Name of the filter field.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * The log content of the filter field must match the specified regular expression.
+         */
+        regex?: pulumi.Input<string>;
+    }
+    interface HostGroupRuleExtractRuleLogTemplate {
+        /**
+         * Log template format
+         */
+        format?: pulumi.Input<string>;
+        /**
+         * Log template type. Supported types: Nginx (Nginx log template type).
+         */
+        type?: pulumi.Input<string>;
+    }
+    interface HostGroupRuleUserDefineRule {
+        /**
+         * Advanced parameters are used for extended configuration. After enabling extended configuration, you can customize advanced behaviors of LogCollector, such as when to release file handles. Note: If multiple conditions for releasing handles are specified, the handle will be released and log file monitoring will end as soon as any condition is met.
+         */
+        advanced?: pulumi.Input<inputs.tls.HostGroupRuleUserDefineRuleAdvanced>;
+        /**
+         * Whether to upload the Label information of the host group to the log service. Disabled by default. true: LogCollector uploads the Label information of the host group to the specified field. You can specify the field name in the HostGroupLabelKey parameter. false (default): LogCollector does not upload the Label information of the host group.
+         */
+        enableHostGroupLabel?: pulumi.Input<boolean>;
+        /**
+         * Whether to upload the hostname field. Default is disabled. true: Adds a field to the original log to record the log source's hostname. Specify the hostname field name using HostnameKey. false (default): Does not add the hostname field.
+         */
+        enableHostname?: pulumi.Input<boolean>;
+        /**
+         * Whether to upload raw logs. true: Upload raw logs. false (default): Do not upload raw logs.
+         */
+        enableRawLog?: pulumi.Input<boolean>;
+        fields?: pulumi.Input<pulumi.Input<inputs.tls.HostGroupRuleUserDefineRuleField>[]>;
+        /**
+         * Field name used to store machine group label information.
+         */
+        hostGroupLabelKey?: pulumi.Input<string>;
+        /**
+         * hostname field name. Only required when EnableHostname is set to true.
+         */
+        hostnameKey?: pulumi.Input<string>;
+        /**
+         * Ignore log files that have not been updated for a specified duration, in hours.
+         */
+        ignoreOlder?: pulumi.Input<number>;
+        /**
+         * Allows multiple log file collections. Empty: Uses the log file ID (including file inode, device, and checksum of the first N bytes) to uniquely identify the log file. RuleID: Uses the collection rule ID and log file ID to uniquely identify the log file. TopicIDRuleName: Uses the log topic ID, collection rule Name, and log file ID to uniquely identify the log file.
+         */
+        multiCollectsType?: pulumi.Input<string>;
+        /**
+         * Rules for parsing the collection path. After setting the rule, fields in the collection path are extracted using the specified regex and added as metadata to the log data. Note: This parameter is not supported when collecting container standard output.
+         */
+        parsePathRule?: pulumi.Input<inputs.tls.HostGroupRuleUserDefineRuleParsePathRule>;
+        /**
+         * LogCollector plugin configuration. After enabling plugin configuration, you can add one or more LogCollector processor plugins to parse logs with complex or variable structures.
+         */
+        plugin?: pulumi.Input<inputs.tls.HostGroupRuleUserDefineRulePlugin>;
+        /**
+         * Original log field name. Only effective when EnableRawLog is set to true. RawLogKey defaults to **raw**, meaning the original log data will be encapsulated in the **raw** field and uploaded to the log service together with the parsed log data
+         */
+        rawLogKey?: pulumi.Input<string>;
+        /**
+         * Rules for routing log partitions. If this parameter is not set, logs are written using the default load balancing mode, and packets are written to any available Shard. If set, logs are collected using the HashKey routing Shard mode, and the log service writes data to the Shard containing the specified Key value.
+         */
+        shardHashKey?: pulumi.Input<inputs.tls.HostGroupRuleUserDefineRuleShardHashKey>;
+        /**
+         * LogCollector collection strategy, specifying whether LogCollector collects incremental logs or full logs. The default is false, which means full log collection. true: incremental collection. When LogCollector collects logs, it only collects newly added content in the file. When a monitored log file receives new log entries, LogCollector is triggered to collect logs. For log files being collected for the first time, LogCollector automatically determines the collection position based on the incremental threshold TailSizeKb you specify. If the new file size does not exceed the incremental threshold, collection starts from the beginning of the new file. If the new file size exceeds the incremental threshold, collection starts from the position at the end of the file minus the incremental threshold, meaning only incremental logs are collected. For log files that are not being collected for the first time, LogCollector determines the collection position based on the Checkpoint and continues collecting. false: (default) full collection. LogCollector collects logs from the beginning of each file, including historical log data.
+         */
+        tailFiles?: pulumi.Input<boolean>;
+        /**
+         * Incremental collection backtracking threshold, in KiB. When LogCollector uses incremental collection, for the first collection of a log file: if the new log file size does not exceed the TailSizeKb value, collection starts from the beginning of the file. If the new log file size exceeds the TailSizeKb value, collection starts from the position TailSizeKb from the end of the file.
+         */
+        tailSizeKb?: pulumi.Input<number>;
+    }
+    interface HostGroupRuleUserDefineRuleAdvanced {
+        /**
+         * After reading to the end of the log file, whether to release the file handle. Default is false.
+         */
+        closeEof?: pulumi.Input<boolean>;
+        /**
+         * Wait time before releasing log file handles. If no new logs are written to a log file for the specified duration, the handle for that log file is released. Unit: seconds. Range: 1–300 seconds. Default: 60 seconds.
+         */
+        closeInactive?: pulumi.Input<number>;
+        /**
+         * Whether to release the handle of the log file after it is removed. Default is false.
+         */
+        closeRemoved?: pulumi.Input<boolean>;
+        /**
+         * Whether to release the handle of the log file after it is renamed. Default is false.
+         */
+        closeRenamed?: pulumi.Input<boolean>;
+        /**
+         * Maximum duration for LogCollector to monitor log files, in seconds. The default is 0 seconds, meaning LogCollector does not limit the monitoring duration. Timing starts when LogCollector begins monitoring the log file. After the specified duration is exceeded, regardless of whether the log file has been fully read, LogCollector immediately releases the file handle and stops monitoring.
+         */
+        closeTimeout?: pulumi.Input<number>;
+        /**
+         * Maximum wait time when LogCollector does not read a line break. Unit: seconds. Default: 5s. LogCollector starts timing when it begins reading log file content. If no line break is read within the specified time, it will send the buffered logs. If the file write interval is large, a complete log entry may be split into two parts and written separately. Adjust this parameter based on your log write interval.
+         */
+        noLineTerminatorEofMaxTime?: pulumi.Input<number>;
+    }
+    interface HostGroupRuleUserDefineRuleField {
+        /**
+         * Key.
          */
-        cronTimeZone?: pulumi.Input<string>;
+        key?: pulumi.Input<string>;
         /**
-         * Scheduling cycle or the specific time point for periodic execution (minutes from 00:00). Value range: 1–1440, in minutes.
+         * Value.
          */
-        time?: pulumi.Input<number>;
+        val?: pulumi.Input<string>;
+    }
+    interface HostGroupRuleUserDefineRuleParsePathRule {
         /**
-         * Scheduling interval type. Options: Period: schedule at regular intervals. Fixed: schedule at a fixed time each day. Cron: use a Cron expression.
+         * List of field names. Log Service parses PathSample into multiple fields using regular expressions (Regex). Keys specify the name of each field. You can configure up to 100 field names. Field names cannot be empty or duplicated.
          */
-        type?: pulumi.Input<string>;
-    }
-    interface AlarmTriggerCondition {
+        keys?: pulumi.Input<pulumi.Input<string>[]>;
         /**
-         * Alert trigger condition expression.
+         * Sample collection path for actual scenarios. The sample path must be an absolute path. Wildcards *, ?, ** are not allowed in the sample path.
          */
-        condition?: pulumi.Input<string>;
+        pathSample?: pulumi.Input<string>;
         /**
-         * Numerical expression for scenarios with data or specific entries, implemented using **count**.
+         * Regular expression used to extract the path field. It must match the example collection path; otherwise, extraction will fail.
          */
-        countCondition?: pulumi.Input<string>;
+        regex?: pulumi.Input<string>;
+    }
+    interface HostGroupRuleUserDefineRulePlugin {
         /**
-         * When enabled, if the result after set operations is an empty set, a separate no-data alert is triggered.
+         * LogCollector plugins. For supported plugin lists and parameter descriptions, see LogCollector plugin overview.
          */
-        noData?: pulumi.Input<boolean>;
+        processors?: pulumi.Input<string>;
+    }
+    interface HostGroupRuleUserDefineRuleShardHashKey {
         /**
-         * Alert notification level, indicating the severity of the alert. Supports notice, warning, or critical, with severity increasing in that order. The default is notice.
+         * The HashKey of the log group specifies the shard where the current log group will be written. The valid range for this parameter is [00000000000000000000000000000000-ffffffffffffffffffffffffffffffff).
          */
-        severity?: pulumi.Input<string>;
+        hashKey?: pulumi.Input<string>;
     }
     interface ImportTaskImportSourceInfo {
         /**
@@ -11645,6 +12609,283 @@ export declare namespace tos {
          */
         storageClass?: pulumi.Input<string>;
     }
+    interface BucketMirrorBackRule {
+        /**
+         * Conditions that trigger the back-to-origin function.
+         */
+        condition?: pulumi.Input<inputs.tos.BucketMirrorBackRuleCondition>;
+        /**
+         * Rule ID. The unique identifier for the back-to-origin rule configured on the current bucket. You can set this yourself to distinguish between multiple rules. Restrictions:
+         * Characters supported: letters, numbers,   - and _.
+         * Maximum length: 32 characters.
+         */
+        id?: pulumi.Input<string>;
+        /**
+         * Back-to-origin redirect configuration.
+         */
+        redirect?: pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirect>;
+    }
+    interface BucketMirrorBackRuleCondition {
+        /**
+         * Supports triggering origin fetch only for specified domains. The domain must be able to access the bucket; it is recommended to use a custom domain bound to the bucket. Limit: supports up to 30 domains.
+         */
+        allowHosts?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * Error code that triggers origin fetch. When a download request returns this error code, origin fetch is triggered. Limit: currently only supports 404.
+         */
+        httpCode?: pulumi.Input<number>;
+        /**
+         * Request types that trigger back-to-origin. Value description:
+         * ["GET","HEAD"]: Both GetObject and HeadObject requests can trigger back-to-origin.
+         * ["GET"]: Only GetObject requests can trigger back-to-origin.
+         * Default is ["GET"].
+         */
+        httpMethods?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * Object name prefix for matching origin fetch objects. Limit: supports up to 512 characters.
+         */
+        keyPrefix?: pulumi.Input<string>;
+        /**
+         * Object name suffix for matching origin fetch objects. Limit: supports up to 512 characters.
+         */
+        keySuffix?: pulumi.Input<string>;
+    }
+    interface BucketMirrorBackRuleRedirect {
+        fetchHeaderToMetaDataRules?: pulumi.Input<pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectFetchHeaderToMetaDataRule>[]>;
+        /**
+         * Whether to fetch data from the configured origin after redirection. Value description: true: Fetch data from the configured origin after redirection. false: Do not fetch data from the configured origin after redirection.
+         */
+        fetchSourceOnRedirect?: pulumi.Input<boolean>;
+        /**
+         * Whether to include request parameters when fetching data after redirection. If not configured, inherits PassQuery settings: true: includes request parameters. false: does not include request parameters.
+         */
+        fetchSourceOnRedirectWithQuery?: pulumi.Input<boolean>;
+        /**
+         * If the result of mirror origin fetch is 3xx, whether to continue redirecting to the specified Location to fetch data. Value description: true: TOS will continue to request the address corresponding to Location. false: TOS will return 302.
+         */
+        followRedirect?: pulumi.Input<boolean>;
+        /**
+         * Specify the headers to include when mirroring back to origin.
+         */
+        mirrorHeader?: pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectMirrorHeader>;
+        /**
+         * List of origin response headers allowed to be passed through directly.
+         */
+        passHeaderFromSources?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * Whether to include request parameters when performing redirect or mirror back-to-origin rules. Value description:
+         * true: Include request parameters.
+         * false: Do not include request parameters.
+         */
+        passQuery?: pulumi.Input<boolean>;
+        /**
+         * List of origin response status codes allowed to be passed through directly.
+         */
+        passStatusCodeFromSources?: pulumi.Input<pulumi.Input<number>[]>;
+        /**
+         * Back-to-origin address configuration when the origin server is a private bucket.
+         */
+        privateSource?: pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectPrivateSource>;
+        /**
+         * Back-to-origin address configuration when the origin server is a public bucket.
+         */
+        publicSource?: pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectPublicSource>;
+        /**
+         * Specify redirect type. Value range: Mirror: Mirror origin fetch. Async: Redirect origin fetch.
+         */
+        redirectType?: pulumi.Input<string>;
+        /**
+         * Define transformations for the object name when requesting the origin server.
+         */
+        transform?: pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectTransform>;
+    }
+    interface BucketMirrorBackRuleRedirectFetchHeaderToMetaDataRule {
+        /**
+         * Suffix appended when writing object metadata.
+         */
+        metaDataSuffix?: pulumi.Input<string>;
+        /**
+         * Origin response header name.
+         */
+        sourceHeader?: pulumi.Input<string>;
+    }
+    interface BucketMirrorBackRuleRedirectMirrorHeader {
+        /**
+         * Whether to forward all HTTP headers to the origin. Values: true: forwards all HTTP headers to the origin. false: does not forward all HTTP headers to the origin. The following HTTP header types are not supported for forwarding: Host, Content-Length, Date, Authorization.
+         */
+        passAll?: pulumi.Input<boolean>;
+        /**
+         * Pass the specified headers to the origin server. Limit: up to 64.
+         */
+        passes?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * Prohibit forwarding specified headers to the origin. Limit: maximum 64.
+         */
+        removes?: pulumi.Input<pulumi.Input<string>[]>;
+        sets?: pulumi.Input<pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectMirrorHeaderSet>[]>;
+    }
+    interface BucketMirrorBackRuleRedirectMirrorHeaderSet {
+        /**
+         * Request header name.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Request header value.
+         */
+        value?: pulumi.Input<string>;
+    }
+    interface BucketMirrorBackRuleRedirectPrivateSource {
+        /**
+         * Back-to-origin address configuration when the origin server is a private bucket.
+         */
+        sourceEndpoint?: pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectPrivateSourceSourceEndpoint>;
+    }
+    interface BucketMirrorBackRuleRedirectPrivateSourceSourceEndpoint {
+        followers?: pulumi.Input<pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointFollower>[]>;
+        primaries?: pulumi.Input<pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointPrimary>[]>;
+    }
+    interface BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointFollower {
+        /**
+         * Name of the origin fetch bucket. Required when the origin is a private bucket.
+         */
+        bucketName?: pulumi.Input<string>;
+        /**
+         * Private back-to-origin authentication method. Required when the origin server is a private bucket.
+         */
+        credentialProvider?: pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointFollowerCredentialProvider>;
+        /**
+         * Access domain name of the origin service provider, excluding bucket name, maximum length 255. Required for private buckets.
+         */
+        endpoint?: pulumi.Input<string>;
+    }
+    interface BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointFollowerCredentialProvider {
+        /**
+         * Region where the origin fetch bucket is located. Required when using AK/SK authentication.
+         */
+        region?: pulumi.Input<string>;
+        /**
+         * Name of AssumeRole. Only when fetching from a private TOS bucket can AssumeRole be used for authentication. Role authentication and AK/SK authentication are mutually exclusive and cannot be set simultaneously.
+         */
+        role?: pulumi.Input<string>;
+        /**
+         * Authenticate using AK/SK.
+         */
+        staticCredential?: pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointFollowerCredentialProviderStaticCredential>;
+    }
+    interface BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointFollowerCredentialProviderStaticCredential {
+        /**
+         * AccessKey ID of the origin bucket. Required when using AK/SK authentication.
+         */
+        ak?: pulumi.Input<string>;
+        /**
+         * SecretKey for the back-to-origin bucket. Required when using AK/SK authentication.
+         */
+        sk?: pulumi.Input<string>;
+        /**
+         * Encryption method used for SecretKey. Values:
+         * Empty: SecretKey is in plaintext. After receiving the SecretKey, the server will encrypt and store it.
+         * AES256: SecretKey has been encrypted using the AES256 algorithm on the server side. After receiving the SecretKey, the server will parse and encrypt it for storage.
+         * Note: When a back-to-origin rule is created for the first time, the SecretKey is encrypted with AES256. If you modify the back-to-origin rule without changing the SecretKey parameter, you must first decrypt the SecretKey and then re-encrypt it for storage. Therefore, when calling the PutBucketMirrorBack API to modify the back-to-origin rule and only changing other parameters (not the SecretKey), you can set SKEncryptType to AES256.
+         */
+        skEncryptType?: pulumi.Input<string>;
+        /**
+         * Origin service provider. Values: BOS: Baidu Cloud. S3: Other cloud providers using the S3 storage protocol.
+         */
+        storageVendor?: pulumi.Input<string>;
+    }
+    interface BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointPrimary {
+        /**
+         * Name of the origin fetch bucket. Required when the origin is a private bucket.
+         */
+        bucketName?: pulumi.Input<string>;
+        /**
+         * Private back-to-origin authentication method. Required when the origin server is a private bucket.
+         */
+        credentialProvider?: pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointPrimaryCredentialProvider>;
+        /**
+         * Access domain name of the origin service provider, excluding bucket name, maximum length 255. Required for private buckets.
+         */
+        endpoint?: pulumi.Input<string>;
+    }
+    interface BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointPrimaryCredentialProvider {
+        /**
+         * Region where the origin fetch bucket is located. Required when using AK/SK authentication.
+         */
+        region?: pulumi.Input<string>;
+        /**
+         * Name of AssumeRole. Only when fetching from a private TOS bucket can AssumeRole be used for authentication. Role authentication and AK/SK authentication are mutually exclusive and cannot be set simultaneously.
+         */
+        role?: pulumi.Input<string>;
+        /**
+         * Authenticate using AK/SK.
+         */
+        staticCredential?: pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointPrimaryCredentialProviderStaticCredential>;
+    }
+    interface BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointPrimaryCredentialProviderStaticCredential {
+        /**
+         * AccessKey ID of the origin bucket. Required when using AK/SK authentication.
+         */
+        ak?: pulumi.Input<string>;
+        /**
+         * SecretKey for the back-to-origin bucket. Required when using AK/SK authentication.
+         */
+        sk?: pulumi.Input<string>;
+        /**
+         * Encryption method used for SecretKey. Values:
+         * Empty: SecretKey is in plaintext. After receiving the SecretKey, the server will encrypt and store it.
+         * AES256: SecretKey has been encrypted using the AES256 algorithm on the server side. After receiving the SecretKey, the server will parse and encrypt it for storage.
+         * Note: When a back-to-origin rule is created for the first time, the SecretKey is encrypted with AES256. If you modify the back-to-origin rule without changing the SecretKey parameter, you must first decrypt the SecretKey and then re-encrypt it for storage. Therefore, when calling the PutBucketMirrorBack API to modify the back-to-origin rule and only changing other parameters (not the SecretKey), you can set SKEncryptType to AES256.
+         */
+        skEncryptType?: pulumi.Input<string>;
+        /**
+         * Origin service provider. Values: BOS: Baidu Cloud. S3: Other cloud providers using the S3 storage protocol.
+         */
+        storageVendor?: pulumi.Input<string>;
+    }
+    interface BucketMirrorBackRuleRedirectPublicSource {
+        /**
+         * Whether to always use the configured origin address.
+         */
+        fixedEndpoint?: pulumi.Input<boolean>;
+        /**
+         * Publicly accessible origin address.
+         */
+        sourceEndpoint?: pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectPublicSourceSourceEndpoint>;
+    }
+    interface BucketMirrorBackRuleRedirectPublicSourceSourceEndpoint {
+        /**
+         * Origin address. Limit: Maximum length 255, supports up to 5 origin fetch addresses. When all origin fetches fail in Primary, an origin is selected from this configuration.
+         */
+        followers?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * Origin address. Limit: Maximum length 255, supports up to 5 origin fetch addresses.
+         */
+        primaries?: pulumi.Input<pulumi.Input<string>[]>;
+    }
+    interface BucketMirrorBackRuleRedirectTransform {
+        /**
+         * Object name prefix to be replaced when requesting the origin.
+         */
+        replaceKeyPrefix?: pulumi.Input<inputs.tos.BucketMirrorBackRuleRedirectTransformReplaceKeyPrefix>;
+        /**
+         * Prefix added before the object name when requesting the origin server. Limit: up to 512 characters.
+         */
+        withKeyPrefix?: pulumi.Input<string>;
+        /**
+         * Prefix added before the object name when requesting the origin server. Limit: up to 512 characters.
+         */
+        withKeySuffix?: pulumi.Input<string>;
+    }
+    interface BucketMirrorBackRuleRedirectTransformReplaceKeyPrefix {
+        /**
+         * Object name prefix to be replaced when requesting the origin. Limit: Supports up to 512 characters.
+         */
+        keyPrefix?: pulumi.Input<string>;
+        /**
+         * Value of the object name prefix after replacement when requesting the origin. Limit: Supports up to 512 characters.
+         */
+        replaceWith?: pulumi.Input<string>;
+    }
     interface BucketNotificationNotificationRule {
         /**
          * Event notification delivery targets. Must include at least one target and supports up to five different targets.
@@ -11733,6 +12974,36 @@ export declare namespace tos {
          */
         value?: pulumi.Input<string>;
     }
+    interface BucketObjectLockConfiguration {
+        /**
+         * Enable retention policy Only Enabled is supported, which means the retention policy is enabled
+         */
+        objectLockEnabled?: pulumi.Input<string>;
+        /**
+         * Bucket retention policy rules
+         */
+        rule?: pulumi.Input<inputs.tos.BucketObjectLockConfigurationRule>;
+    }
+    interface BucketObjectLockConfigurationRule {
+        /**
+         * Default bucket retention policy
+         */
+        defaultRetention?: pulumi.Input<inputs.tos.BucketObjectLockConfigurationRuleDefaultRetention>;
+    }
+    interface BucketObjectLockConfigurationRuleDefaultRetention {
+        /**
+         * Object lock days Objects cannot be deleted or overwritten during the specified number of days. Measured in days
+         */
+        days?: pulumi.Input<number>;
+        /**
+         * Retention policy mode Only COMPLIANCE is supported, which means compliance mode. In this mode, no user can delete or overwrite locked objects during the retention period
+         */
+        mode?: pulumi.Input<string>;
+        /**
+         * Object lock years Objects cannot be deleted or overwritten during the specified number of years. Measured in years, with one year equal to 365 days
+         */
+        years?: pulumi.Input<number>;
+    }
     interface BucketRealtimeLogRealTimeLog {
         /**
          * Role name. Used to grant TOS Object Storage permission to create resources such as projects and topics in Log Service TLS and to write logs
@@ -11761,6 +13032,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 {
@@ -12202,6 +13541,32 @@ export declare namespace vedbm {
         value?: pulumi.Input<string>;
     }
 }
+export declare namespace veenedge {
+    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 {
         /**
@@ -15011,4 +16376,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>;
+    }
 }