@volcengine/pulumi-volcenginecc 0.0.30 → 0.0.32

package/types/input.d.ts

@@ -1284,6 +1284,14 @@ export declare namespace autoscaling {
         volumeType?: pulumi.Input<string>;
     }
     interface ScalingGroupInstance {
+        /**
+         * Time when the instance joined the scaling group
+         */
+        createdTime?: pulumi.Input<string>;
+        /**
+         * How the instance joined the scaling group (Attached / AutoCreated)
+         */
+        creationType?: pulumi.Input<string>;
         /**
          * Whether to enable managed mode for the instance when AttachInstances is performed
          */
@@ -1292,10 +1300,34 @@ export declare namespace autoscaling {
          * ECS instance ID, unique identifier of the subresource
          */
         instanceId?: pulumi.Input<string>;
+        /**
+         * Launch template ID used by the instance
+         */
+        launchTemplateId?: pulumi.Input<string>;
+        /**
+         * Launch template version used by the instance
+         */
+        launchTemplateVersion?: pulumi.Input<string>;
         /**
          * Whether to trigger lifecycle hooks when the instance is attached, detached, or removed
          */
         lifecycleHook?: pulumi.Input<boolean>;
+        /**
+         * Scaling configuration ID associated with the instance
+         */
+        scalingConfigurationId?: pulumi.Input<string>;
+        /**
+         * Scaling policy ID associated with the instance
+         */
+        scalingPolicyId?: pulumi.Input<string>;
+        /**
+         * Current status of the instance in the scaling group
+         */
+        status?: pulumi.Input<string>;
+        /**
+         * Availability zone of the instance
+         */
+        zoneId?: pulumi.Input<string>;
     }
     interface ScalingGroupInstanceRemovePolicy {
         /**
@@ -3832,6 +3864,16 @@ export declare namespace cdn {
     }
 }
 export declare namespace cen {
+    interface BandwidthPackageTag {
+        /**
+         * Tag key for user tags. Parameter   - N: indicates the tag key index, value range: 1–20. Use & to separate multiple tag keys. Cannot start with sys:, in any case. Length range: 1–128 characters. Supports all languages, numbers, spaces ( ), underscores (_), periods (.), colons (:), slashes (/), equals (=), plus (+), hyphens (-), and @ (@). If a tag key starts or ends with a space, the system automatically removes it.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Tag value for user tags. Parameter   - N indicates the tag value index, range: 1–20. Use & to separate multiple tag values. Length range: 0–256 characters. If not specified, defaults to empty. Supports all languages, numbers, spaces ( ), underscores (_), periods (.), colons (:), slashes (/), equals signs (=), plus signs (+), hyphens (-), and @ (@). Case-sensitive. If the tag value starts or ends with a space, the system automatically removes it.
+         */
+        value?: pulumi.Input<string>;
+    }
     interface CenInstance {
         /**
          * Network instance ID
@@ -3860,6 +3902,20 @@ export declare namespace cen {
          */
         value?: pulumi.Input<string>;
     }
+    interface ServiceRouteEntryPublishToInstance {
+        /**
+         * Network instance ID for published cloud service access route.
+         */
+        instanceId?: pulumi.Input<string>;
+        /**
+         * Region for published cloud service access route.
+         */
+        instanceRegionId?: pulumi.Input<string>;
+        /**
+         * Network instance type for published cloud service access route.
+         */
+        instanceType?: pulumi.Input<string>;
+    }
 }
 export declare namespace clb {
     interface AclAclEntry {
@@ -3982,6 +4038,28 @@ export declare namespace clb {
          */
         eniId?: pulumi.Input<string>;
     }
+    interface ClbIpv6AddressBandwidth {
+        /**
+         * Peak bandwidth of IPv6 public bandwidth, in Mbps
+         */
+        bandwidth?: pulumi.Input<number>;
+        /**
+         * Shared bandwidth package ID associated with IPv6 public bandwidth
+         */
+        bandwidthPackageId?: pulumi.Input<string>;
+        /**
+         * Billing type for IPv6 public bandwidth
+         */
+        billingType?: pulumi.Input<number>;
+        /**
+         * Line type of IPv6 public bandwidth
+         */
+        isp?: pulumi.Input<string>;
+        /**
+         * Network type of the load balancer instance's IPv6 address
+         */
+        networkType?: pulumi.Input<string>;
+    }
     interface ClbListener {
         /**
          * Listener ID
@@ -4012,6 +4090,20 @@ export declare namespace clb {
          */
         value?: pulumi.Input<string>;
     }
+    interface ListenerDomainExtension {
+        /**
+         * Certificate ID of the extended domain name.
+         */
+        certCenterCertificateId?: pulumi.Input<string>;
+        /**
+         * Certificate source for the extended domain name to be added. Value: cert_center: SSL certificate from Volcano Engine Certificate Center. This parameter is required when adding an extended domain name.
+         */
+        certificateSource?: pulumi.Input<string>;
+        /**
+         * Domain name. Supports both wildcard and exact domain names. Specifications: 1. Must contain at least one '.', and cannot start or end with '.'. 2. Only letters, numbers, '.', '-', and '*' are allowed. 3. Length must be between 1 and 128 characters. 4. Wildcard domain: Use '*' to replace one or more characters. 5. Exact domain: A domain name that strictly follows domain name specifications.
+         */
+        domain?: pulumi.Input<string>;
+    }
     interface ListenerHealthCheck {
         /**
          * Domain name for health check. Must be set to the actual address provided by the backend server. This parameter takes effect when Protocol is set to HTTP or HTTPS and HealthCheck.Enabled is on. Must contain at least one period (.), and cannot start or end with a period (.). Each string can include letters, numbers, hyphens (-), and periods (.), with hyphens (-) not allowed at the beginning or end of the string. Length limit: 1 to 128 characters. If this parameter is not provided or no value is specified, the default is empty, meaning CLB uses the private IP address of each backend server for health checks.
@@ -4504,6 +4596,10 @@ export declare namespace cloudmonitor {
          * Comparison operators. Supports standard threshold alerting: >, >=, <, <=, !=, =, as well as the following period-over-period alerting: last*period*increase*pct: Increased compared to last period. last*period*decrease*pct: Decreased compared to last period. last*period*abs*pct: Increased or decreased compared to last period. last*day*increase*pct: Increased compared to the same period yesterday. last*day*decrease*pct: Decreased compared to the same period yesterday. last*day*abs*pct: Increased or decreased compared to the same period yesterday. last*week*increase*pct: Increased compared to the same period last week. last*week*decrease*pct: Decreased compared to the same period last week. last*week*abs_pct: Increased or decreased compared to the same period last week.
          */
         comparisonOperator?: pulumi.Input<string>;
+        /**
+         * Metric display name.
+         */
+        displayName?: pulumi.Input<string>;
         /**
          * Monitoring metric name. For details, see MetricName for each product in Cloud Monitoring Metric Query.
          */
@@ -5024,6 +5120,18 @@ export declare namespace ecs {
          * The number of IPv6 addresses for the instance.
          */
         ipv6AddressCount?: pulumi.Input<number>;
+        /**
+         * IPv6 address of the instance.
+         */
+        ipv6Addresses?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * Instance MAC address.
+         */
+        macAddress?: pulumi.Input<string>;
+        /**
+         * The network interface ID of the instance.
+         */
+        networkInterfaceId?: pulumi.Input<string>;
         /**
          * Instance primary IP address
          */
@@ -5040,6 +5148,10 @@ export declare namespace ecs {
          * Instance subnet ID.
          */
         subnetId?: pulumi.Input<string>;
+        /**
+         * VPC ID of the instance.
+         */
+        vpcId?: pulumi.Input<string>;
     }
     interface InstanceSystemVolume {
         /**
@@ -7493,10 +7605,6 @@ export declare namespace privatelink {
         value?: pulumi.Input<string>;
     }
     interface EndpointServiceResource {
-        /**
-         * Endpoint service ID.
-         */
-        instanceId?: pulumi.Input<string>;
         /**
          * Service resource ID to be added to the endpoint service.
          */
@@ -7516,6 +7624,82 @@ export declare namespace privatelink {
          */
         value?: pulumi.Input<string>;
     }
+    interface VpcEndpointConnectionResourcesAllocate {
+        /**
+         * Specify the service resource for the endpoint connection
+         */
+        resourceId?: pulumi.Input<string>;
+        /**
+         * Availability zone ID of the service resource to be specified
+         */
+        zoneId?: pulumi.Input<string>;
+    }
+    interface VpcEndpointConnectionZone {
+        /**
+         * Endpoint network interface ID. If a seamless service resource replacement is in progress, this indicates the endpoint network interface ID connected to the replaced service resource
+         */
+        networkInterfaceId?: pulumi.Input<string>;
+        /**
+         * The private IPv4 address of the terminal node NIC. If a smooth service resource replacement is in progress, this refers to the IPv4 address of the terminal node NIC connected to the service resource being replaced.
+         */
+        networkInterfaceIp?: pulumi.Input<string>;
+        /**
+         * Private IPv6 address of the endpoint network interface. If a seamless service resource replacement is in progress, this indicates the IPv6 address of the endpoint network interface connected to the replaced service resource. If the endpoint only supports IPv4, this parameter is not returned
+         */
+        networkInterfaceIpv6?: pulumi.Input<string>;
+        /**
+         * Service resource ID
+         */
+        resourceId?: pulumi.Input<string>;
+        /**
+         * Status of the service resource
+         */
+        serviceStatus?: pulumi.Input<string>;
+        /**
+         * ID of the subnet to which the endpoint network interface belongs
+         */
+        subnetId?: pulumi.Input<string>;
+        /**
+         * The domain name of the terminal node availability zone.
+         */
+        zoneDomain?: pulumi.Input<string>;
+        /**
+         * Endpoint zone ID
+         */
+        zoneId?: pulumi.Input<string>;
+        /**
+         * Status of the endpoint zone. PendingAcceptance: waiting for connection. Connecting: connecting. Connected: connected. Disconnecting: disconnecting. Rejected: connection rejected. Failed: connection failed
+         */
+        zoneStatus?: pulumi.Input<string>;
+    }
+    interface VpcEndpointTag {
+        /**
+         * Tag key of the endpoint user tag. Length limit: 1–128 characters. Case sensitive. Cannot start with 'or' or 'sys:' in any case combination. Cannot start or end with a space. Allowed characters: letters, numbers, spaces ( ), underscores (_), periods (.), colons (:), slashes (/), equal signs (=), plus signs (+), hyphens (-), and @.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Tag value of the endpoint user tag. Length limit: 0–256 characters. Case sensitive. Cannot start or end with a space. Allowed characters: letters, numbers, spaces ( ), underscores (_), periods (.), colons (:), slashes (/), equal signs (=), plus signs (+), hyphens (-), and @
+         */
+        value?: pulumi.Input<string>;
+    }
+    interface VpcEndpointZone {
+        /**
+         * The private IPv4 address of the endpoint node's network interface must belong to the subnet's IPv4 CIDR block. You can call the DescribeSubnets API to obtain the subnet's CIDR block. Parameter -N: indicates the sequence number of the private IPv4 address, with a value range of 1–10. Use & to separate multiple private IPv4 addresses.
+         */
+        privateIpAddress?: pulumi.Input<string>;
+        /**
+         * The private IPv6 address of the endpoint node's network interface must belong to the subnet's IPv6 CIDR block. You can call the DescribeSubnets API to obtain the subnet's CIDR block. Parameter -N: indicates the sequence number of the private IPv6 address, with a value range of 1–10. Use & to separate multiple private IPv6 addresses. If not specified, an IPv6 address will be randomly assigned within the subnet's IPv6 CIDR block by default.
+         */
+        privateIpv6Address?: pulumi.Input<string>;
+        /**
+         * ID of the subnet to which the NIC of the endpoint to be created belongs. You can call the DescribeSubnets API to obtain the subnet ID. Parameter -N: Indicates the sequence number of the subnet ID, value range: 1–10. Separate multiple subnet IDs with &.
+         */
+        subnetId?: pulumi.Input<string>;
+        /**
+         * ID of the availability zone to which the NIC of the endpoint to be created belongs. For more information about availability zones, see Regions and Availability Zones. Parameter -N: Indicates the sequence number of the availability zone, value range: 1–10. Separate multiple availability zone IDs with &.
+         */
+        zoneId?: pulumi.Input<string>;
+    }
 }
 export declare namespace privatezone {
     interface ResolverEndpointIpConfig {
@@ -7578,6 +7762,12 @@ export declare namespace privatezone {
     }
 }
 export declare namespace rabbitmq {
+    interface AllowListAssociatedInstance {
+        /**
+         * Instance ID
+         */
+        instanceId?: pulumi.Input<string>;
+    }
     interface InstanceChargeDetail {
         /**
          * Whether to automatically renew the subscription instance after expiration.
@@ -7725,6 +7915,26 @@ export declare namespace rdsmssql {
          * Instance ID
          */
         instanceId?: pulumi.Input<string>;
+        /**
+         * Instance name
+         */
+        instanceName?: pulumi.Input<string>;
+        /**
+         * Instance status
+         */
+        instanceStatus?: pulumi.Input<string>;
+        /**
+         * Sync latest allowlist IP
+         */
+        isLatest?: pulumi.Input<boolean>;
+        /**
+         * Project name of the instance
+         */
+        projectName?: pulumi.Input<string>;
+        /**
+         * VPC ID of the instance
+         */
+        vpc?: pulumi.Input<string>;
     }
     interface InstanceChargeInfo {
         /**
@@ -8385,133 +8595,397 @@ export declare namespace rdspostgresql {
          */
         weight?: pulumi.Input<number>;
     }
-}
-export declare namespace redis {
-    interface InstanceCapacity {
+    interface InstanceChargeDetail {
         /**
-         * Total memory capacity of the current instance. Unit: MiB.
+         * Enable auto-renewal for prepaid scenarios
          */
-        total?: pulumi.Input<number>;
+        autoRenew?: pulumi.Input<boolean>;
         /**
-         * Used capacity of the current instance. Unit: MiB.
+         * Billing expiration time for yearly/monthly instances
          */
-        used?: pulumi.Input<number>;
-    }
-    interface InstanceConfigureNode {
+        chargeEndTime?: pulumi.Input<string>;
         /**
-         * The availability zone each node belongs to.
+         * Instance billing start time
          */
-        az?: pulumi.Input<string>;
-    }
-    interface InstanceInstanceShard {
+        chargeStartTime?: pulumi.Input<string>;
         /**
-         * Number of nodes in each shard
+         * Payment status. Value:   - `Normal`: Normal   - `Overdue`: Overdue and suspended   - `Unpaid`: Unpaid
          */
-        nodeNumber?: pulumi.Input<number>;
-        serverNodes?: pulumi.Input<pulumi.Input<inputs.redis.InstanceInstanceShardServerNode>[]>;
+        chargeStatus?: pulumi.Input<string>;
         /**
-         * Shard ID.
+         * Payment type. Value:   - `PostPaid`: Postpaid   - `PrePaid`: Prepaid
          */
-        shardId?: pulumi.Input<string>;
-    }
-    interface InstanceInstanceShardServerNode {
+        chargeType: pulumi.Input<string>;
         /**
-         * Current role of the node. Valid values: PrimaryNode: primary node; SecondaryNode: secondary node.
+         * Estimated release time after instance suspension due to overdue payment
          */
-        currentRole?: pulumi.Input<string>;
+        overdueReclaimTime?: pulumi.Input<string>;
         /**
-         * Node ID.
+         * Instance shutdown time due to overdue payment
          */
-        nodeId?: pulumi.Input<string>;
+        overdueTime?: pulumi.Input<string>;
         /**
-         * Node status. Valid values: deploy: starting; running: running; loading: loading data; error: error.
+         * Purchase duration for prepaid scenarios
          */
-        status?: pulumi.Input<string>;
+        period?: pulumi.Input<number>;
         /**
-         * Availability zone where the node is located.
+         * Purchase period for prepaid scenarios. Values:   - `Month`: month   - `Year`: year
          */
-        zoneId?: pulumi.Input<string>;
-    }
-    interface InstanceTag {
+        periodUnit?: pulumi.Input<string>;
         /**
-         * Tag key.
+         * Rollback time for temporary upgrade
          */
-        key?: pulumi.Input<string>;
+        tempModifyEndTime?: pulumi.Input<string>;
         /**
-         * Tag value.
+         * Start time of temporary scaling
          */
-        value?: pulumi.Input<string>;
+        tempModifyStartTime?: pulumi.Input<string>;
     }
-    interface InstanceVisitAddr {
+    interface InstanceEndpoint {
+        addresses?: pulumi.Input<pulumi.Input<inputs.rdspostgresql.InstanceEndpointAddress>[]>;
         /**
-         * Connection address type. Value options: Private: Private network connection address; Public: Public network connection address; DirectLink: Direct connection address.
+         * When the terminal type is read-write or read-only, you can set whether new nodes join automatically. Values:   - `Enable`: join automatically   - `Disable`: do not join automatically (default)
          */
-        addrType?: pulumi.Input<string>;
+        autoAddNewNodes?: pulumi.Input<string>;
         /**
-         * IP address or domain name.
+         * Address description.
          */
-        address?: pulumi.Input<string>;
+        description?: pulumi.Input<string>;
         /**
-         * EIP ID bound to the instance's public address. This parameter is returned only when the connection address type (AddrType) is Public.
+         * Enable global read-only mode.   - `Enable`: enabled   - `Disable`: not enabled
          */
-        eipId?: pulumi.Input<string>;
+        enableReadOnly?: pulumi.Input<string>;
         /**
-         * Port number.
+         * Enable read-write separation. Values:   - `Enable`: enabled   - `Disable`: not enabled
          */
-        port?: pulumi.Input<string>;
+        enableReadWriteSplitting?: pulumi.Input<string>;
         /**
-         * IPv6 address corresponding to the connection address.
+         * Instance connection terminal ID
          */
-        viPv6?: pulumi.Input<string>;
+        endpointId?: pulumi.Input<string>;
         /**
-         * The IPv4 address corresponding to the connection address.
+         * Instance connection terminal name
          */
-        vip?: pulumi.Input<string>;
-    }
-}
-export declare namespace rocketmq {
-    interface AllowListAssociatedInstance {
+        endpointName?: pulumi.Input<string>;
         /**
-         * Instance ID
+         * Endpoint type:   - `Cluster`: Default endpoint (created by default)   - `Custom`: Custom endpoint
          */
-        instanceId?: pulumi.Input<string>;
-    }
-    interface GroupConsumedClient {
+        endpointType?: pulumi.Input<string>;
         /**
-         * Address and port of this consumer instance.
+         * Read-only weight allocation mode. Options:   - `Default`: Standard weight allocation (default).   - `Custom`: Custom weight allocation
          */
-        clientAddress?: pulumi.Input<string>;
+        readOnlyNodeDistributionType?: pulumi.Input<string>;
         /**
-         * ID of this consumer instance.
+         * Maximum latency threshold for read-only nodes. If a read-only node's latency exceeds this value, read traffic will not be sent to that node. Unit: seconds. Range: 0~3600. Default: 30.
+         * **Note:** This parameter can be set for the default endpoint when read/write splitting is enabled.
          */
-        clientId?: pulumi.Input<string>;
+        readOnlyNodeMaxDelayTime?: pulumi.Input<number>;
+        readOnlyNodeWeights?: pulumi.Input<pulumi.Input<inputs.rdspostgresql.InstanceEndpointReadOnlyNodeWeight>[]>;
         /**
-         * Message backlog.
+         * Read/write mode:   - `ReadWrite`: Read/write   - `ReadOnly`: Read-only
          */
-        diff?: pulumi.Input<number>;
+        readWriteMode?: pulumi.Input<string>;
         /**
-         * Development language of the consumer application.
+         * After read/write splitting is enabled for the terminal, set the number of proxy connections for the terminal.   - The minimum value for proxy connections is 20.   - The maximum value depends on the specification of the instance's primary node. Different specifications support different maximum proxy connections. For details, see [Product Specifications]
          */
-        language?: pulumi.Input<string>;
+        readWriteProxyConnection?: pulumi.Input<number>;
         /**
-         * Consumer version.
+         * Whether the endpoint sends write requests to the write node (currently, only the primary node is the write node). Value:   - `true`: Yes. (Default)   - `false`: No
          */
-        version?: pulumi.Input<string>;
+        writeNodeHaltWriting?: pulumi.Input<boolean>;
     }
-    interface GroupConsumedTopic {
+    interface InstanceEndpointAddress {
         /**
-         * Number of queues associated with the Topic. Each Topic contains one or more queues for storing messages.
+         * Private network address accessible across regions
          */
-        queueNum?: pulumi.Input<number>;
+        crossRegionDomain?: pulumi.Input<string>;
         /**
-         * Subscription rules.
+         * Enable public network resolution. Values:   - false: default, private network resolution   - true: private and public network resolution
          */
-        subString?: pulumi.Input<string>;
+        dnsVisibility?: pulumi.Input<boolean>;
         /**
-         * Name of the Topic subscribed by the client.
+         * Connection domain name
          */
-        topicName?: pulumi.Input<string>;
-    }
+        domain?: pulumi.Input<string>;
+        /**
+         * Private network address type. Values: LocalDomain: local region domain name CrossRegionDomain: cross-region accessible domain name
+         */
+        domainVisibilitySetting?: pulumi.Input<string>;
+        /**
+         * EIP ID, valid only for Public addresses
+         */
+        eipId?: pulumi.Input<string>;
+        /**
+         * IP address
+         */
+        ipAddress?: pulumi.Input<string>;
+        /**
+         * Network address type. Value:   - `Private`: Private network address   - `Public`: Public network address   - `Inner`: Public service zone address
+         */
+        networkType?: pulumi.Input<string>;
+        /**
+         * Port.
+         */
+        port?: pulumi.Input<string>;
+        /**
+         * Subnet ID
+         */
+        subnetId?: pulumi.Input<string>;
+    }
+    interface InstanceEndpointReadOnlyNodeWeight {
+        /**
+         * Read-only nodes require NodeId
+         */
+        nodeId?: pulumi.Input<string>;
+        /**
+         * Node type
+         */
+        nodeType?: pulumi.Input<string>;
+        /**
+         * Node read weight, increases by 100, maximum value is 10000
+         */
+        weight?: pulumi.Input<number>;
+    }
+    interface InstanceMaintenanceWindow {
+        /**
+         * Granularity of the maintenance cycle. Value: Week (week)
+         */
+        dayKind?: pulumi.Input<string>;
+        dayOfWeekMaintenanceTimes?: pulumi.Input<pulumi.Input<inputs.rdspostgresql.InstanceMaintenanceWindowDayOfWeekMaintenanceTime>[]>;
+    }
+    interface InstanceMaintenanceWindowDayOfWeekMaintenanceTime {
+        /**
+         * Specify maintenance days for the instance each week. Multiple selections allowed. Monday: Monday. Tuesday: Tuesday. Wednesday: Wednesday. Thursday: Thursday. Friday: Friday. Saturday: Saturday. Sunday: Sunday. Note: If not specified or left blank, all seven days are enabled by default.
+         */
+        dayOfWeek?: pulumi.Input<string>;
+        /**
+         * Start time of the maintenance window on the maintenance day. Format: HH:mmZ (UTC time). Currently, only start times between 16:00Z and 20:00Z are supported.
+         */
+        maintenanceWindowStartTime?: pulumi.Input<string>;
+        /**
+         * Duration of the maintenance window on the maintenance day. Minimum duration is 2 hours, maximum is 6 hours.
+         */
+        period?: pulumi.Input<number>;
+    }
+    interface InstanceNodeInfo {
+        /**
+         * Node creation time. Format: yyyy-MM-ddTHH:mm:ss.sssZ (UTC time)
+         */
+        createTime?: pulumi.Input<string>;
+        /**
+         * Instance ID
+         */
+        instanceId?: pulumi.Input<string>;
+        /**
+         * Memory size, unit: GB
+         */
+        memory?: pulumi.Input<number>;
+        /**
+         * Node ID
+         */
+        nodeId?: pulumi.Input<string>;
+        /**
+         * Node specification
+         */
+        nodeSpec: pulumi.Input<string>;
+        /**
+         * Node status
+         */
+        nodeStatus?: pulumi.Input<string>;
+        /**
+         * Node type
+         */
+        nodeType: pulumi.Input<string>;
+        /**
+         * Region ID
+         */
+        regionId?: pulumi.Input<string>;
+        /**
+         * Node update time. Format: yyyy-MM-ddTHH:mm:ss.sssZ (UTC time)
+         */
+        updateTime?: pulumi.Input<string>;
+        /**
+         * CPU size. For example: 1 means 1U
+         */
+        vcpu?: pulumi.Input<number>;
+        /**
+         * Availability zone of the node
+         */
+        zoneId: pulumi.Input<string>;
+    }
+    interface InstanceTag {
+        /**
+         * Tag key
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Tag value
+         */
+        value?: pulumi.Input<string>;
+    }
+}
+export declare namespace redis {
+    interface AllowListAssociatedInstance {
+        /**
+         * Instance ID bound to the current allowlist
+         */
+        instanceId?: pulumi.Input<string>;
+        /**
+         * Instance names bound to the current allowlist
+         */
+        instanceName?: pulumi.Input<string>;
+        /**
+         * Project name associated with the instance
+         */
+        projectName?: pulumi.Input<string>;
+        /**
+         * Private network ID associated with the instance
+         */
+        vpc?: pulumi.Input<string>;
+    }
+    interface AllowListSecurityGroupBindInfo {
+        /**
+         * Security group association mode. The value range is as follows: IngressDirectionIp: ingress IP, which allows IPs involved in TCP and ALL protocols in the source address of the security group ingress direction to access the database. If the source address is configured as a security group, it will be ignored. AssociateEcsIp: associate ECS IP, which allows cloud servers within the security group to access the database. Currently, only importing IP information of the primary network interface is supported
+         */
+        bindMode?: pulumi.Input<string>;
+        /**
+         * Associated security group ID
+         */
+        securityGroupId?: pulumi.Input<string>;
+    }
+    interface InstanceCapacity {
+        /**
+         * Total memory capacity of the current instance. Unit: MiB.
+         */
+        total?: pulumi.Input<number>;
+        /**
+         * Used capacity of the current instance. Unit: MiB.
+         */
+        used?: pulumi.Input<number>;
+    }
+    interface InstanceConfigureNode {
+        /**
+         * The availability zone each node belongs to.
+         */
+        az?: pulumi.Input<string>;
+    }
+    interface InstanceInstanceShard {
+        /**
+         * Number of nodes in each shard
+         */
+        nodeNumber?: pulumi.Input<number>;
+        serverNodes?: pulumi.Input<pulumi.Input<inputs.redis.InstanceInstanceShardServerNode>[]>;
+        /**
+         * Shard ID.
+         */
+        shardId?: pulumi.Input<string>;
+    }
+    interface InstanceInstanceShardServerNode {
+        /**
+         * Current role of the node. Valid values: PrimaryNode: primary node; SecondaryNode: secondary node.
+         */
+        currentRole?: pulumi.Input<string>;
+        /**
+         * Node ID.
+         */
+        nodeId?: pulumi.Input<string>;
+        /**
+         * Node status. Valid values: deploy: starting; running: running; loading: loading data; error: error.
+         */
+        status?: pulumi.Input<string>;
+        /**
+         * Availability zone where the node is located.
+         */
+        zoneId?: pulumi.Input<string>;
+    }
+    interface InstanceTag {
+        /**
+         * Tag key.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Tag value.
+         */
+        value?: pulumi.Input<string>;
+    }
+    interface InstanceVisitAddr {
+        /**
+         * Connection address type. Value options: Private: Private network connection address; Public: Public network connection address; DirectLink: Direct connection address.
+         */
+        addrType?: pulumi.Input<string>;
+        /**
+         * IP address or domain name.
+         */
+        address?: pulumi.Input<string>;
+        /**
+         * EIP ID bound to the instance's public address. This parameter is returned only when the connection address type (AddrType) is Public.
+         */
+        eipId?: pulumi.Input<string>;
+        /**
+         * Port number.
+         */
+        port?: pulumi.Input<string>;
+        /**
+         * IPv6 address corresponding to the connection address.
+         */
+        viPv6?: pulumi.Input<string>;
+        /**
+         * The IPv4 address corresponding to the connection address.
+         */
+        vip?: pulumi.Input<string>;
+    }
+}
+export declare namespace rocketmq {
+    interface AllowListAssociatedInstance {
+        /**
+         * Instance ID
+         */
+        instanceId?: pulumi.Input<string>;
+        /**
+         * Instance Name
+         */
+        instanceName?: pulumi.Input<string>;
+        /**
+         * VPC ID of the instance
+         */
+        vpc?: pulumi.Input<string>;
+    }
+    interface GroupConsumedClient {
+        /**
+         * Address and port of this consumer instance.
+         */
+        clientAddress?: pulumi.Input<string>;
+        /**
+         * ID of this consumer instance.
+         */
+        clientId?: pulumi.Input<string>;
+        /**
+         * Message backlog.
+         */
+        diff?: pulumi.Input<number>;
+        /**
+         * Development language of the consumer application.
+         */
+        language?: pulumi.Input<string>;
+        /**
+         * Consumer version.
+         */
+        version?: pulumi.Input<string>;
+    }
+    interface GroupConsumedTopic {
+        /**
+         * Number of queues associated with the Topic. Each Topic contains one or more queues for storing messages.
+         */
+        queueNum?: pulumi.Input<number>;
+        /**
+         * Subscription rules.
+         */
+        subString?: pulumi.Input<string>;
+        /**
+         * Name of the Topic subscribed by the client.
+         */
+        topicName?: pulumi.Input<string>;
+    }
     interface InstanceChargeDetail {
         /**
          * Whether the subscription instance is automatically renewed upon expiration. true: automatically renewed. false: not automatically renewed. Manual renewal is required after expiration; otherwise, the instance will be shut down.
@@ -8646,19 +9120,122 @@ export declare namespace rocketmq {
     }
 }
 export declare namespace storageebs {
-    interface SnapshotTag {
+    interface SnapshotGroupSnapshot {
         /**
-         * User tag key added to the resource. Naming rules: Cannot start with volc: or sys: in any case. Keys starting with volc: or sys: are reserved system tag keys and cannot be created. Only language characters, numbers, spaces, and the following English symbols are allowed: '_', '.', ':', '/', '=', '+', '-', '@'. Length must be between 1 and 128 characters.
+         * Snapshot creation time
          */
-        key?: pulumi.Input<string>;
+        creationTime?: pulumi.Input<string>;
         /**
-         * User tag value added to the resource. Naming rules: Only language characters, numbers, spaces, and the following English symbols are allowed: '_', '.', ':', '/', '=', '+', '-', '@'. Can be empty. Length must be between 0 and 256 characters.
+         * Snapshot description
          */
-        value?: pulumi.Input<string>;
-    }
-    interface VolumeBaselinePerformance {
+        description?: pulumi.Input<string>;
         /**
-         * Total IOPS of the disk, which is the sum of the baseline IOPS and extra IOPS.
+         * Image ID
+         */
+        imageId?: pulumi.Input<string>;
+        /**
+         * Whether the snapshot has enabled ultra-fast availability. Values are as follows:   - true: Ultra-fast availability enabled   - false: Ultra-fast availability not enabled
+         */
+        instantAccess?: pulumi.Input<boolean>;
+        /**
+         * Dump progress
+         */
+        progress?: pulumi.Input<number>;
+        /**
+         * Project of the snapshot
+         */
+        projectName?: pulumi.Input<string>;
+        /**
+         * Retention days for automatic snapshots
+         */
+        retentionDays?: pulumi.Input<number>;
+        /**
+         * Whether the snapshot is shared with others. Values are as follows:   - true: Snapshot is shared with others   - false: Snapshot is not shared with others
+         */
+        shared?: pulumi.Input<boolean>;
+        /**
+         * Snapshot consistency group ID
+         */
+        snapshotGroupId?: pulumi.Input<string>;
+        /**
+         * Snapshot ID
+         */
+        snapshotId?: pulumi.Input<string>;
+        /**
+         * Snapshot name
+         */
+        snapshotName?: pulumi.Input<string>;
+        /**
+         * Snapshot type. Values are as follows:   - user: Manual snapshot   - auto: Automatic snapshot
+         */
+        snapshotType?: pulumi.Input<string>;
+        /**
+         * Snapshot status. Values are as follows:   - available: Available   - creating: Creating   - rollbacking: Rolling back   - deleted: Deleted   - failed: Error
+         */
+        status?: pulumi.Input<string>;
+        tags?: pulumi.Input<pulumi.Input<inputs.storageebs.SnapshotGroupSnapshotTag>[]>;
+        /**
+         * Cloud disk ID
+         */
+        volumeId?: pulumi.Input<string>;
+        /**
+         * Cloud disk category. Values are as follows:   - system: System disk   - data: Data disk
+         */
+        volumeKind?: pulumi.Input<string>;
+        /**
+         * Cloud disk name
+         */
+        volumeName?: pulumi.Input<string>;
+        /**
+         * Cloud disk size (GiB)
+         */
+        volumeSize?: pulumi.Input<number>;
+        /**
+         * Cloud disk status. Values are as follows:   - available: Available   - attaching: Attaching   - attached: Attached   - detaching: Detaching   - creating: Creating   - deleting: Deleting   - error: Error   - extending: Expanding
+         */
+        volumeStatus?: pulumi.Input<string>;
+        /**
+         * Cloud disk type. Values are as follows:   - ESSD*PL0: Ultra-fast SSD cloud disk, PL0 specification   - ESSD*FlexPL: Ultra-fast SSD cloud disk, FlexPL specification   - TSSD_TL0: Throughput SSD cloud disk
+         */
+        volumeType?: pulumi.Input<string>;
+        /**
+         * Zone ID. If ultra-fast availability is enabled for the snapshot, you can create a cloud disk in this zone using the ultra-fast available snapshot
+         */
+        zoneId?: pulumi.Input<string>;
+    }
+    interface SnapshotGroupSnapshotTag {
+        /**
+         * Tag key
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Tag value
+         */
+        value?: pulumi.Input<string>;
+    }
+    interface SnapshotGroupTag {
+        /**
+         * Tag key
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Tag value
+         */
+        value?: pulumi.Input<string>;
+    }
+    interface SnapshotTag {
+        /**
+         * User tag key added to the resource. Naming rules: Cannot start with volc: or sys: in any case. Keys starting with volc: or sys: are reserved system tag keys and cannot be created. Only language characters, numbers, spaces, and the following English symbols are allowed: '_', '.', ':', '/', '=', '+', '-', '@'. Length must be between 1 and 128 characters.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * User tag value added to the resource. Naming rules: Only language characters, numbers, spaces, and the following English symbols are allowed: '_', '.', ':', '/', '=', '+', '-', '@'. Can be empty. Length must be between 0 and 256 characters.
+         */
+        value?: pulumi.Input<string>;
+    }
+    interface VolumeBaselinePerformance {
+        /**
+         * Total IOPS of the disk, which is the sum of the baseline IOPS and extra IOPS.
          */
         iops?: pulumi.Input<number>;
         /**
@@ -8702,201 +9279,1068 @@ export declare namespace storageebs {
     }
 }
 export declare namespace tls {
-    interface IndexFullText {
+    interface AlarmNotifyGroupNoticeRule {
+        /**
+         * Whether there is an end node afterwards.
+         */
+        hasEndNode?: pulumi.Input<boolean>;
+        /**
+         * Condition for whether to proceed to the next level.
+         */
+        hasNext?: pulumi.Input<boolean>;
+        receiverInfos?: pulumi.Input<pulumi.Input<inputs.tls.AlarmNotifyGroupNoticeRuleReceiverInfo>[]>;
+        /**
+         * Rule node. JSON format.
+         */
+        ruleNode?: pulumi.Input<string>;
+    }
+    interface AlarmNotifyGroupNoticeRuleReceiverInfo {
+        /**
+         * Alarm content template ID.
+         */
+        alarmContentTemplateId?: pulumi.Input<string>;
+        /**
+         * User group name to notify when sending notifications to Feishu, DingTalk, or WeCom via Webhook integration.
+         */
+        alarmWebhookAtGroups?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * Username to notify when sending notifications to Feishu, DingTalk, or WeCom via Webhook integration.
+         */
+        alarmWebhookAtUsers?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * Alarm webhook integration configuration ID.
+         */
+        alarmWebhookIntegrationId?: pulumi.Input<string>;
+        /**
+         * Name of the alarm Webhook integration configuration.
+         */
+        alarmWebhookIntegrationName?: pulumi.Input<string>;
+        /**
+         * Whether to notify everyone when sending notifications to Feishu, DingTalk, or WeCom via Webhook integration.
+         */
+        alarmWebhookIsAtAll?: pulumi.Input<boolean>;
+        /**
+         * End time for receiving alarm notifications. Uses 24-hour format: HH:mm:ss, with a valid range of 00:00:00–23:59:59. StartTime cannot be greater than EndTime.
+         */
+        endTime?: pulumi.Input<string>;
+        /**
+         * Custom WebHook request body. It is recommended to set the request body according to the callback interface requirements of the corresponding service.
+         */
+        generalWebhookBody?: pulumi.Input<string>;
+        generalWebhookHeaders?: pulumi.Input<pulumi.Input<inputs.tls.AlarmNotifyGroupNoticeRuleReceiverInfoGeneralWebhookHeader>[]>;
+        /**
+         * Custom callback method for the interface. Only POST or PUT is supported.
+         */
+        generalWebhookMethod?: pulumi.Input<string>;
+        /**
+         * Custom callback URL for the interface.
+         */
+        generalWebhookUrl?: pulumi.Input<string>;
+        /**
+         * Notification channels. Supports one or more channels. Options: Email, Sms, Phone, GeneralWebhook, Lark, DingTalk, WeChat.
+         */
+        receiverChannels?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * IAM user or user group name.
+         */
+        receiverNames?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * Recipient type. Options: User: IAM user; UserGroup: IAM user group.
+         */
+        receiverType?: pulumi.Input<string>;
+        /**
+         * Alarm notification start time. Uses 24-hour format (HH:mm:ss), valid range is 00:00:00–23:59:59. StartTime cannot be later than EndTime.
+         */
+        startTime?: pulumi.Input<string>;
+    }
+    interface AlarmNotifyGroupNoticeRuleReceiverInfoGeneralWebhookHeader {
+        /**
+         * Custom request header key.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Custom request header value.
+         */
+        value?: pulumi.Input<string>;
+    }
+    interface AlarmNotifyGroupReceiver {
+        /**
+         * Alarm content template ID.
+         */
+        alarmContentTemplateId?: pulumi.Input<string>;
+        /**
+         * User group name to notify when sending notifications to Feishu, DingTalk, or WeCom via Webhook integration.
+         */
+        alarmWebhookAtGroups?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * Username to notify when sending notifications to Feishu, DingTalk, or WeCom via Webhook integration.
+         */
+        alarmWebhookAtUsers?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * Alarm webhook integration configuration ID.
+         */
+        alarmWebhookIntegrationId?: pulumi.Input<string>;
+        /**
+         * Name of the alarm Webhook integration configuration.
+         */
+        alarmWebhookIntegrationName?: pulumi.Input<string>;
+        /**
+         * Whether to notify everyone when sending notifications to Feishu, DingTalk, or WeCom via Webhook integration.
+         */
+        alarmWebhookIsAtAll?: pulumi.Input<boolean>;
+        /**
+         * End time for receiving alarm notifications. Uses 24-hour format: HH:mm:ss, with a valid range of 00:00:00–23:59:59. StartTime cannot be greater than EndTime.
+         */
+        endTime?: pulumi.Input<string>;
+        /**
+         * Custom WebHook request body. It is recommended to set the request body according to the callback interface requirements of the corresponding service.
+         */
+        generalWebhookBody?: pulumi.Input<string>;
+        generalWebhookHeaders?: pulumi.Input<pulumi.Input<inputs.tls.AlarmNotifyGroupReceiverGeneralWebhookHeader>[]>;
+        /**
+         * Custom callback method for the interface. Only POST or PUT is supported.
+         */
+        generalWebhookMethod?: pulumi.Input<string>;
+        /**
+         * Custom callback URL for the interface.
+         */
+        generalWebhookUrl?: pulumi.Input<string>;
+        /**
+         * Notification channels. Supports one or more channels. Options: Email, Sms, Phone, GeneralWebhook, Lark, DingTalk, WeChat.
+         */
+        receiverChannels?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * IAM user or user group name.
+         */
+        receiverNames?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * Recipient type. Options: User: IAM user; UserGroup: IAM user group.
+         */
+        receiverType?: pulumi.Input<string>;
+        /**
+         * Alarm notification start time. Uses 24-hour format (HH:mm:ss), valid range is 00:00:00–23:59:59. StartTime cannot be later than EndTime.
+         */
+        startTime?: pulumi.Input<string>;
+    }
+    interface AlarmNotifyGroupReceiverGeneralWebhookHeader {
+        /**
+         * Custom request header key.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Custom request header value.
+         */
+        value?: pulumi.Input<string>;
+    }
+    interface ImportTaskImportSourceInfo {
+        /**
+         * Kafka data source information. When sourceType is kafka, the KafkaSourceInfo field is required
+         */
+        kafkaSourceInfo?: pulumi.Input<inputs.tls.ImportTaskImportSourceInfoKafkaSourceInfo>;
+        /**
+         * TOS data source information. When sourceType is tos, the TosSourceInfo field is required.
+         */
+        tosSourceInfo?: pulumi.Input<inputs.tls.ImportTaskImportSourceInfoTosSourceInfo>;
+    }
+    interface ImportTaskImportSourceInfoKafkaSourceInfo {
+        /**
+         * Data encoding format. Available options: UTF-8, GBK.
+         */
+        encode?: pulumi.Input<string>;
+        /**
+         * Kafka consumer group. If not specified, the system will automatically create a Kafka consumer group.
+         */
+        group?: pulumi.Input<string>;
+        /**
+         * The service addresses for different types of Kafka clusters vary. Details are as follows: Message Queue Kafka Edition: Use the access point of the Kafka instance. For more information, see Access Point. If the Kafka instance and the Log Service Project are in the same region, you can use private network access; otherwise, use public network access. Self-hosted Kafka clusters: Use the IP address and port number or the domain name and port number of the Kafka Broker. Only public network access is supported. Separate multiple service addresses with a comma (,).
+         */
+        host?: pulumi.Input<string>;
+        /**
+         * Starting position for data import. Options: 0: Earliest time, start importing from the first record in the specified Kafka Topic. 1: Latest time, start importing from the most recently generated record in the specified Kafka Topic.
+         */
+        initialOffset?: pulumi.Input<number>;
+        /**
+         * If you are using Message Queue Kafka Edition, set this to the Kafka instance ID.
+         */
+        instanceId?: pulumi.Input<string>;
+        /**
+         * Whether to enable authentication. If you use a public service address, it is recommended to enable authentication.
+         */
+        isNeedAuth?: pulumi.Input<boolean>;
+        /**
+         * Password authentication mechanism. Available options: PLAIN, SCRAM-SHA-256, and SCRAM-SHA-512.
+         */
+        mechanism?: pulumi.Input<string>;
+        /**
+         * Kafka SASL user password for authentication.
+         */
+        password?: pulumi.Input<string>;
+        /**
+         * Secure transmission protocol. Options include plaintext, sasl*ssl, ssl, and sasl*plaintext
+         */
+        protocol?: pulumi.Input<string>;
+        /**
+         * Specify log time. Options: 0: Use Kafka message timestamp. 1: Use current system time.
+         */
+        timeSourceDefault?: pulumi.Input<number>;
+        /**
+         * Kafka Topic name. Separate multiple Kafka Topics with commas (,).
+         */
+        topic?: pulumi.Input<string>;
+        /**
+         * Kafka SASL username for authentication.
+         */
+        username?: pulumi.Input<string>;
+    }
+    interface ImportTaskImportSourceInfoTosSourceInfo {
+        /**
+         * TOS bucket name
+         */
+        bucket?: pulumi.Input<string>;
+        /**
+         * Compression mode for data in the TOS bucket. none: No compression. snappy: Compress using snappy. gzip: Compress using gzip. lz4: Compress using lz4.
+         */
+        compressType?: pulumi.Input<string>;
+        /**
+         * Path of the file to be imported in the TOS bucket.
+         */
+        prefix?: pulumi.Input<string>;
+        /**
+         * Region where the TOS bucket is located. Cross-region data import is supported
+         */
+        region?: pulumi.Input<string>;
+    }
+    interface ImportTaskTargetInfo {
+        /**
+         * Log extraction rule.
+         */
+        extractRule?: pulumi.Input<inputs.tls.ImportTaskTargetInfoExtractRule>;
+        /**
+         * Log sample. When LogType is set to multiline_log, you must configure log samples. It is recommended to provide more than two log entries as examples to ensure the regular expression matches the first line of each log. Use real samples from the production environment.
+         */
+        logSample?: pulumi.Input<string>;
+        /**
+         * Specify log parsing type during import. delimiter*log: CSV type. multiline*log: multiline full text type. minimalist*log: single line full text type. json*log: JSON type.
+         */
+        logType: pulumi.Input<string>;
+        /**
+         * Region.
+         */
+        region: pulumi.Input<string>;
+    }
+    interface ImportTaskTargetInfoExtractRule {
+        /**
+         * Basic content of log extraction rules.
+         */
+        extractRule?: pulumi.Input<inputs.tls.ImportTaskTargetInfoExtractRuleExtractRule>;
+        /**
+         * Number of skipped rows. Only valid when the log type is delimiterLog and the import type is tos.
+         */
+        skipLineCount?: pulumi.Input<number>;
+        /**
+         * Time extraction regular expression, used to extract the time value from the TimeKey field and parse it as the collection time
+         */
+        timeExtractRegex?: pulumi.Input<string>;
+        /**
+         * Time zone. Supports machine time zone (default) and custom time zone. Custom time zone supports GMT and UTC. GMT format: GMT+08:00. UTC format: Asia/Shanghai.
+         */
+        timeZone?: pulumi.Input<string>;
+    }
+    interface ImportTaskTargetInfoExtractRuleExtractRule {
+        /**
+         * Regular expression for identifying the first line of each log. The matched part is treated as the start of the log. When LogType is set to multiline_log, you must configure a log sample
+         */
+        beginRegex?: pulumi.Input<string>;
+        /**
+         * Delimiter. Only valid when LogType is delimiter_log.
+         */
+        delimiter?: pulumi.Input<string>;
+        /**
+         * Enable nanoseconds.
+         */
+        enableNanosecond?: pulumi.Input<boolean>;
+        filterKeyRegexes?: pulumi.Input<pulumi.Input<inputs.tls.ImportTaskTargetInfoExtractRuleExtractRuleFilterKeyRegex>[]>;
+        /**
+         * List of log field names (Key). Valid only when LogType is delimiter_log. Supports up to 100 field names. Duplicate field names are not allowed, and all field names cannot be left blank
+         */
+        keys?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * Log regular expression
+         */
+        logRegex?: pulumi.Input<string>;
+        /**
+         * Log template.
+         */
+        logTemplate?: pulumi.Input<inputs.tls.ImportTaskTargetInfoExtractRuleExtractRuleLogTemplate>;
+        /**
+         * Quotation mark. Content enclosed by the quotation mark will not be separated and will be parsed as a complete field. Only valid when LogType is delimiter_log.
+         */
+        quote?: pulumi.Input<string>;
+        /**
+         * Parsing format for the time field. If you use a specified time field in the log as the log timestamp, you must fill in TimeKey and TimeFormat. TimeKey and TimeFormat must be paired. For configuration details, see time format.
+         */
+        timeFormat?: pulumi.Input<string>;
+        /**
+         * Name of the log time field. If you use a specific time field in the log as the log timestamp, you must provide both TimeKey and TimeFormat. TimeKey and TimeFormat must appear in pairs
+         */
+        timeKey?: pulumi.Input<string>;
+        /**
+         * Time sample. Used to verify whether the entered time parsing format is correct
+         */
+        timeSample?: pulumi.Input<string>;
+        /**
+         * When uploading logs that failed to parse, specify the key name for the failed logs. UnMatchUpLoadSwitch=true and UnMatchLogKey must be used together.
+         */
+        unMatchLogKey?: pulumi.Input<string>;
+        /**
+         * Whether to upload logs that failed to parse. UnMatchUpLoadSwitch=true and UnMatchLogKey must be paired. true: Upload logs that failed to parse. false: Do not upload logs that failed to parse.
+         */
+        unMatchUpLoadSwitch?: pulumi.Input<boolean>;
+    }
+    interface ImportTaskTargetInfoExtractRuleExtractRuleFilterKeyRegex {
+        /**
+         * Key.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Regular expression.
+         */
+        regex?: pulumi.Input<string>;
+    }
+    interface ImportTaskTargetInfoExtractRuleExtractRuleLogTemplate {
+        /**
+         * Format.
+         */
+        format?: pulumi.Input<string>;
+        /**
+         * Type
+         */
+        type?: pulumi.Input<string>;
+    }
+    interface ImportTaskTaskStatistics {
+        /**
+         * Total resource bytes enumerated
+         */
+        bytesTotal?: pulumi.Input<number>;
+        /**
+         * Bytes transferred.
+         */
+        bytesTransferred?: pulumi.Input<number>;
+        /**
+         * Number of resources failed to import.
+         */
+        failed?: pulumi.Input<number>;
+        /**
+         * Number of resources not found.
+         */
+        notExist?: pulumi.Input<number>;
+        /**
+         * Number of resources skipped during import
+         */
+        skipped?: pulumi.Input<number>;
+        /**
+         * Task status. Status of the import task. Preparing: Preparing for import. Importing: Importing data. Success: Import completed successfully. Failed: Import failed. Stopped: Import paused.
+         */
+        taskStatus?: pulumi.Input<string>;
+        /**
+         * Total number of resources enumerated.
+         */
+        total?: pulumi.Input<number>;
+        /**
+         * Number of records transferred.
+         */
+        transferred?: pulumi.Input<number>;
+    }
+    interface IndexFullText {
+        /**
+         * Case sensitivity. true: Case sensitive. false: Not case sensitive.
+         */
+        caseSensitive?: pulumi.Input<boolean>;
+        /**
+         * Token separators for the full-text index. Each character in the string represents a token separator. Length: 1–256 bytes. Only one or more of the following characters are supported: letters, numbers, and !@#%^&*()-_=\\"', <>/?|;:\	\r[]{}. . Supports configuring both Chinese characters and token separators simultaneously.
+         */
+        delimiter?: pulumi.Input<string>;
+        /**
+         * When searching, specify whether to segment Chinese content in logs according to Chinese grammar. The default is false. true: For Chinese characters in logs, segment the log according to common Chinese grammar rules. Custom segmentation symbols for Chinese content are not supported. For non-Chinese characters in logs, segment the log using the segmentation symbols specified in the parameter. false: Segment the log using the segmentation symbols specified in the parameter.
+         */
+        includeChinese?: pulumi.Input<boolean>;
+    }
+    interface IndexKeyValue {
+        /**
+         * Specify the field names for key-value indexing. Up to 100 fields can be added. Only letters, numbers, spaces, underscores (_), hyphens (-), and slashes (/) are supported, and field names cannot start or end with a space. Each key name must be unique within the same index. Length: 1–128 characters. For subfields in JSON-type key-value indexes, use a dot (.) to indicate the hierarchy between JSON fields. For example, if the JSON field 'namelist' contains a text-type subfield 'totalcount' and a JSON-type subfield 'info', and 'info' contains the field 'name', the field names should be configured as 'totalcount' and 'info.name' respectively.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Field description information required for configuring key-value indexes.
+         */
+        value?: pulumi.Input<inputs.tls.IndexKeyValueValue>;
+    }
+    interface IndexKeyValueValue {
+        /**
+         * Indicates whether the index was added automatically. true: The index was added automatically. false: The index was not added automatically.
+         */
+        autoIndexFlag?: pulumi.Input<boolean>;
+        /**
+         * Whether to distinguish case. Default is false.
+         */
+        caseSensitive?: pulumi.Input<boolean>;
+        /**
+         * Token separators for the field. Default is empty (""). Each character in the string represents a token separator. Length: 0–256 bytes. If the length is 0, segmentation is disabled. Only one or more of the following characters are supported: letters, numbers, and !@#%^&*()-_=\\"', <>/?|;:\	\r[]{}. . Supports configuring both Chinese characters and token separators simultaneously.
+         */
+        delimiter?: pulumi.Input<string>;
+        /**
+         * When searching, determines whether to segment Chinese log content according to Chinese syntax. Enabled: Chinese characters in logs are segmented based on common Chinese syntax; custom segmentation for Chinese content is not supported. Non-Chinese characters in logs are segmented using the token separators specified in the parameter. Disabled: Logs are segmented using the token separators specified in the parameter.
+         */
+        includeChinese?: pulumi.Input<boolean>;
+        /**
+         * Create indexes for all fields with text values in the JSON field.
+         */
+        indexAll?: pulumi.Input<boolean>;
+        /**
+         * Enable automatic indexing and statistics for JSON fields. true: Enable automatic indexing and statistics. false: Disable automatic indexing and statistics.
+         */
+        indexSqlAll?: pulumi.Input<boolean>;
+        jsonKeys?: pulumi.Input<pulumi.Input<inputs.tls.IndexKeyValueValueJsonKey>[]>;
+        /**
+         * Whether analysis is enabled for the field. Default is false. After enabling statistical analysis, you can configure token delimiters and whether to include Chinese content.
+         */
+        sqlFlag?: pulumi.Input<boolean>;
+        /**
+         * Field type. Currently supports long, double, text, and json. The long and double types do not support configuring delimiters, including Chinese, or case sensitivity. Only the json type supports further configuration of JsonKeys subfields.
+         */
+        valueType?: pulumi.Input<string>;
+    }
+    interface IndexKeyValueValueJsonKey {
+        /**
+         * Specify the field names for key-value indexing. Up to 100 fields can be added. Only letters, numbers, spaces, underscores (_), hyphens (-), and slashes (/) are supported, and field names cannot start or end with a space. Each key name must be unique within the same index. Length: 1–128 characters. For subfields in JSON-type key-value indexes, use a dot (.) to indicate the hierarchy between JSON fields. For example, if the JSON field 'namelist' contains a text-type subfield 'totalcount' and a JSON-type subfield 'info', and 'info' contains the field 'name', the field names should be configured as 'totalcount' and 'info.name' respectively.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Field description information required for configuring key-value indexes.
+         */
+        value?: pulumi.Input<inputs.tls.IndexKeyValueValueJsonKeyValue>;
+    }
+    interface IndexKeyValueValueJsonKeyValue {
+        /**
+         * Indicates whether the index was added automatically. true: The index was added automatically. false: The index was not added automatically.
+         */
+        autoIndexFlag?: pulumi.Input<boolean>;
+        /**
+         * Whether to distinguish case. Default is false.
+         */
+        caseSensitive?: pulumi.Input<boolean>;
+        /**
+         * Token separators for the field. Default is empty (""). Each character in the string represents a token separator. Length: 0–256 bytes. If the length is 0, segmentation is disabled. Only one or more of the following characters are supported: letters, numbers, and !@#%^&*()-_=\\"', <>/?|;:\	\r[]{}. . Supports configuring both Chinese characters and token separators simultaneously.
+         */
+        delimiter?: pulumi.Input<string>;
+        /**
+         * When searching, determines whether to segment Chinese log content according to Chinese syntax. Enabled: Chinese characters in logs are segmented based on common Chinese syntax; custom segmentation for Chinese content is not supported. Non-Chinese characters in logs are segmented using the token separators specified in the parameter. Disabled: Logs are segmented using the token separators specified in the parameter.
+         */
+        includeChinese?: pulumi.Input<boolean>;
+        /**
+         * Create indexes for all fields with text values in the JSON field.
+         */
+        indexAll?: pulumi.Input<boolean>;
+        /**
+         * Enable automatic indexing and statistics for JSON fields. true: Enable automatic indexing and statistics. false: Disable automatic indexing and statistics.
+         */
+        indexSqlAll?: pulumi.Input<boolean>;
+        /**
+         * Whether analysis is enabled for the field. Default is false. After enabling statistical analysis, you can configure token delimiters and whether to include Chinese content.
+         */
+        sqlFlag?: pulumi.Input<boolean>;
+        /**
+         * Field type. Currently supports long, double, text, and json. The long and double types do not support configuring delimiters, including Chinese, or case sensitivity. Only the json type supports further configuration of JsonKeys subfields.
+         */
+        valueType?: pulumi.Input<string>;
+    }
+    interface IndexUserInnerKeyValue {
+        /**
+         * Specify the field names for key-value indexing. Up to 100 fields can be added. Only letters, numbers, spaces, underscores (_), hyphens (-), and slashes (/) are supported, and field names cannot start or end with a space. Each key name must be unique within the same index. Length: 1–128 characters. For subfields in JSON-type key-value indexes, use a dot (.) to indicate the hierarchy between JSON fields. For example, if the JSON field 'namelist' contains a text-type subfield 'totalcount' and a JSON-type subfield 'info', and 'info' contains the field 'name', the field names should be configured as 'totalcount' and 'info.name' respectively.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Field description information required for configuring key-value indexes.
+         */
+        value?: pulumi.Input<inputs.tls.IndexUserInnerKeyValueValue>;
+    }
+    interface IndexUserInnerKeyValueValue {
+        /**
+         * Indicates whether the index was added automatically. true: The index was added automatically. false: The index was not added automatically.
+         */
+        autoIndexFlag?: pulumi.Input<boolean>;
+        /**
+         * Whether to distinguish case. Default is false.
+         */
+        caseSensitive?: pulumi.Input<boolean>;
+        /**
+         * Token separators for the field. Default is empty (""). Each character in the string represents a token separator. Length: 0–256 bytes. If the length is 0, segmentation is disabled. Only one or more of the following characters are supported: letters, numbers, and !@#%^&*()-_=\\"', <>/?|;:\	\r[]{}. . Supports configuring both Chinese characters and token separators simultaneously.
+         */
+        delimiter?: pulumi.Input<string>;
+        /**
+         * When searching, determines whether to segment Chinese log content according to Chinese syntax. Enabled: Chinese characters in logs are segmented based on common Chinese syntax; custom segmentation for Chinese content is not supported. Non-Chinese characters in logs are segmented using the token separators specified in the parameter. Disabled: Logs are segmented using the token separators specified in the parameter.
+         */
+        includeChinese?: pulumi.Input<boolean>;
+        /**
+         * Create indexes for all fields with text values in the JSON field.
+         */
+        indexAll?: pulumi.Input<boolean>;
+        /**
+         * Enable automatic indexing and statistics for JSON fields. true: Enable automatic indexing and statistics. false: Disable automatic indexing and statistics.
+         */
+        indexSqlAll?: pulumi.Input<boolean>;
+        jsonKeys?: pulumi.Input<pulumi.Input<inputs.tls.IndexUserInnerKeyValueValueJsonKey>[]>;
+        /**
+         * Whether analysis is enabled for the field. Default is false. After enabling statistical analysis, you can configure token delimiters and whether to include Chinese content.
+         */
+        sqlFlag?: pulumi.Input<boolean>;
+        /**
+         * Field type. Currently supports long, double, text, and json. The long and double types do not support configuring delimiters, including Chinese, or case sensitivity. Only the json type supports further configuration of JsonKeys subfields.
+         */
+        valueType?: pulumi.Input<string>;
+    }
+    interface IndexUserInnerKeyValueValueJsonKey {
+        /**
+         * Specify the field names for key-value indexing. Up to 100 fields can be added. Only letters, numbers, spaces, underscores (_), hyphens (-), and slashes (/) are supported, and field names cannot start or end with a space. Each key name must be unique within the same index. Length: 1–128 characters. For subfields in JSON-type key-value indexes, use a dot (.) to indicate the hierarchy between JSON fields. For example, if the JSON field 'namelist' contains a text-type subfield 'totalcount' and a JSON-type subfield 'info', and 'info' contains the field 'name', the field names should be configured as 'totalcount' and 'info.name' respectively.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Field description information required for configuring key-value indexes.
+         */
+        value?: pulumi.Input<inputs.tls.IndexUserInnerKeyValueValueJsonKeyValue>;
+    }
+    interface IndexUserInnerKeyValueValueJsonKeyValue {
+        /**
+         * Indicates whether the index was added automatically. true: The index was added automatically. false: The index was not added automatically.
+         */
+        autoIndexFlag?: pulumi.Input<boolean>;
+        /**
+         * Whether to distinguish case. Default is false.
+         */
+        caseSensitive?: pulumi.Input<boolean>;
+        /**
+         * Token separators for the field. Default is empty (""). Each character in the string represents a token separator. Length: 0–256 bytes. If the length is 0, segmentation is disabled. Only one or more of the following characters are supported: letters, numbers, and !@#%^&*()-_=\\"', <>/?|;:\	\r[]{}. . Supports configuring both Chinese characters and token separators simultaneously.
+         */
+        delimiter?: pulumi.Input<string>;
+        /**
+         * When searching, determines whether to segment Chinese log content according to Chinese syntax. Enabled: Chinese characters in logs are segmented based on common Chinese syntax; custom segmentation for Chinese content is not supported. Non-Chinese characters in logs are segmented using the token separators specified in the parameter. Disabled: Logs are segmented using the token separators specified in the parameter.
+         */
+        includeChinese?: pulumi.Input<boolean>;
+        /**
+         * Create indexes for all fields with text values in the JSON field.
+         */
+        indexAll?: pulumi.Input<boolean>;
+        /**
+         * Enable automatic indexing and statistics for JSON fields. true: Enable automatic indexing and statistics. false: Disable automatic indexing and statistics.
+         */
+        indexSqlAll?: pulumi.Input<boolean>;
+        /**
+         * Whether analysis is enabled for the field. Default is false. After enabling statistical analysis, you can configure token delimiters and whether to include Chinese content.
+         */
+        sqlFlag?: pulumi.Input<boolean>;
+        /**
+         * Field type. Currently supports long, double, text, and json. The long and double types do not support configuring delimiters, including Chinese, or case sensitivity. Only the json type supports further configuration of JsonKeys subfields.
+         */
+        valueType?: pulumi.Input<string>;
+    }
+    interface ProjectTag {
+        /**
+         * Tag key
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Tag value
+         */
+        value?: pulumi.Input<string>;
+    }
+    interface RuleContainerRule {
+        /**
+         * Container name to collect. If no container name is specified, all containers in the machine group will be collected. Supports regex matching; for example, setting the container name to ^(container-test)$ will collect all containers named container-test.
+         */
+        containerNameRegex?: pulumi.Input<string>;
+        envTags?: pulumi.Input<pulumi.Input<inputs.tls.RuleContainerRuleEnvTag>[]>;
+        excludeContainerEnvRegexes?: pulumi.Input<pulumi.Input<inputs.tls.RuleContainerRuleExcludeContainerEnvRegex>[]>;
+        excludeContainerLabelRegexes?: pulumi.Input<pulumi.Input<inputs.tls.RuleContainerRuleExcludeContainerLabelRegex>[]>;
+        includeContainerEnvRegexes?: pulumi.Input<pulumi.Input<inputs.tls.RuleContainerRuleIncludeContainerEnvRegex>[]>;
+        includeContainerLabelRegexes?: pulumi.Input<pulumi.Input<inputs.tls.RuleContainerRuleIncludeContainerLabelRegex>[]>;
+        /**
+         * Kubernetes container collection rules.
+         */
+        kubernetesRule?: pulumi.Input<inputs.tls.RuleContainerRuleKubernetesRule>;
+        /**
+         * Collection information. stdout: Collects container standard output (stdout). stderr: Collects container standard error (stderr). all: Collects both container standard output (stdout) and standard error (stderr).
+         */
+        stream?: pulumi.Input<string>;
+    }
+    interface RuleContainerRuleEnvTag {
+        /**
+         * Key.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Value.
+         */
+        val?: pulumi.Input<string>;
+    }
+    interface RuleContainerRuleExcludeContainerEnvRegex {
+        /**
+         * Key.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Value.
+         */
+        val?: pulumi.Input<string>;
+    }
+    interface RuleContainerRuleExcludeContainerLabelRegex {
+        /**
+         * Key.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Value.
+         */
+        val?: pulumi.Input<string>;
+    }
+    interface RuleContainerRuleIncludeContainerEnvRegex {
+        /**
+         * Key.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Value.
+         */
+        val?: pulumi.Input<string>;
+    }
+    interface RuleContainerRuleIncludeContainerLabelRegex {
+        /**
+         * Key.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Value.
+         */
+        val?: pulumi.Input<string>;
+    }
+    interface RuleContainerRuleKubernetesRule {
+        annotationTags?: pulumi.Input<pulumi.Input<inputs.tls.RuleContainerRuleKubernetesRuleAnnotationTag>[]>;
+        /**
+         * Whether to add all Kubernetes Labels as log tags to the original log data. When enabled, the log service adds fields for all Labels in the Kubernetes Pod to the logs. For example, if the Pod contains Label source=DC and destination=CS, the logs will include fields **tag**source__: DC and **tag**destination__: CS.
+         */
+        enableAllLabelTag?: pulumi.Input<boolean>;
+        excludePodAnnotationRegexes?: pulumi.Input<pulumi.Input<inputs.tls.RuleContainerRuleKubernetesRuleExcludePodAnnotationRegex>[]>;
+        excludePodLabelRegexes?: pulumi.Input<pulumi.Input<inputs.tls.RuleContainerRuleKubernetesRuleExcludePodLabelRegex>[]>;
+        includePodAnnotationRegexes?: pulumi.Input<pulumi.Input<inputs.tls.RuleContainerRuleKubernetesRuleIncludePodAnnotationRegex>[]>;
+        includePodLabelRegexes?: pulumi.Input<pulumi.Input<inputs.tls.RuleContainerRuleKubernetesRuleIncludePodLabelRegex>[]>;
+        labelTags?: pulumi.Input<pulumi.Input<inputs.tls.RuleContainerRuleKubernetesRuleLabelTag>[]>;
+        /**
+         * Name of the Kubernetes Namespace to collect. If no Namespace name is specified, all containers will be collected. Namespace names support regular expression matching. For example, if you set the Namespace name to ^(tcp|udp)$, it will collect all containers under the tcp and udp namespaces.
+         */
+        namespaceNameRegex?: pulumi.Input<string>;
+        /**
+         * Pod name is used to specify the Pod whose containers will be collected. If no Pod name is specified, all containers will be collected. Pod name supports regular expression 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 the container 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: Deployment: stateless workload StatefulSet: stateful workload DaemonSet: daemon process Job: task CronJob: scheduled task
+         */
+        workloadType?: pulumi.Input<string>;
+    }
+    interface RuleContainerRuleKubernetesRuleAnnotationTag {
+        /**
+         * Key.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Value.
+         */
+        val?: pulumi.Input<string>;
+    }
+    interface RuleContainerRuleKubernetesRuleExcludePodAnnotationRegex {
+        /**
+         * Key.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Value.
+         */
+        val?: pulumi.Input<string>;
+    }
+    interface RuleContainerRuleKubernetesRuleExcludePodLabelRegex {
+        /**
+         * Key.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Value.
+         */
+        val?: pulumi.Input<string>;
+    }
+    interface RuleContainerRuleKubernetesRuleIncludePodAnnotationRegex {
+        /**
+         * Key.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Value.
+         */
+        val?: pulumi.Input<string>;
+    }
+    interface RuleContainerRuleKubernetesRuleIncludePodLabelRegex {
+        /**
+         * Key.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Value.
+         */
+        val?: pulumi.Input<string>;
+    }
+    interface RuleContainerRuleKubernetesRuleLabelTag {
+        /**
+         * Key.
+         */
+        key?: pulumi.Input<string>;
+        /**
+         * Value.
+         */
+        val?: pulumi.Input<string>;
+    }
+    interface RuleExcludePath {
+        /**
+         * 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 RuleExtractRule {
+        /**
+         * Regular expression that the first line of the log must match. Valid only when LogType is multiline*log or fullregex*log. 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 include and report nanosecond precision. true: Enable nanosecond precision time. false: Disable nanosecond precision time.
+         */
+        enableNanosecond?: pulumi.Input<boolean>;
+        filterKeyRegexes?: pulumi.Input<pulumi.Input<inputs.tls.RuleExtractRuleFilterKeyRegex>[]>;
+        /**
+         * List of log field names (Key). This is only valid when LogType is delimiter*log or fullregex*log. You can configure up to 100 field names. When LogType is delimiter*log, field names must be unique and cannot all be empty. When LogType is fullregex*log, field names must be unique and cannot be empty.
+         */
+        keys?: pulumi.Input<pulumi.Input<string>[]>;
+        /**
+         * The entire log must match the specified regular expression. This is only valid when the collected log type is fullregex_log. Must be a valid regular expression.
+         */
+        logRegex?: pulumi.Input<string>;
+        /**
+         * Automatically extract log fields based on the specified log template
+         */
+        logTemplate?: pulumi.Input<inputs.tls.RuleExtractRuleLogTemplate>;
+        /**
+         * Quoting character. Content wrapped by a quoting character will not be split but parsed as a complete field. 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 you use a specific time field in the log as the log timestamp, you must provide both TimeKey and TimeFormat. TimeKey and TimeFormat must be used together.
+         */
+        timeFormat?: pulumi.Input<string>;
+        /**
+         * Name of the log time field. If you want to use a specific time field in the log as the log timestamp, you need to specify both TimeKey and TimeFormat. TimeKey and TimeFormat must be provided together.
+         */
+        timeKey?: pulumi.Input<string>;
+        /**
+         * Time sample. Used to check whether the entered 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. GMT format: GMT+08:00. UTC format: Asia/Shanghai.
+         */
+        timeZone?: pulumi.Input<string>;
+        /**
+         * Key name for unmatched logs.
+         */
+        unMatchLogKey?: pulumi.Input<string>;
+        /**
+         * Switch for uploading unmatched logs.
+         */
+        unMatchUpLoadSwitch?: pulumi.Input<boolean>;
+    }
+    interface RuleExtractRuleFilterKeyRegex {
+        /**
+         * 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 RuleExtractRuleLogTemplate {
+        /**
+         * Log template format.
+         */
+        format?: pulumi.Input<string>;
+        /**
+         * Log template types. Supported types: Nginx: Nginx log template.
+         */
+        type?: pulumi.Input<string>;
+    }
+    interface RuleHostGroupInfo {
+        /**
+         * Machine group ID
+         */
+        hostGroupId?: pulumi.Input<string>;
+    }
+    interface RuleUserDefineRule {
+        /**
+         * The Advanced parameter is 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 release conditions are specified, the handle is released and log file monitoring ends as soon as any condition is met.
+         */
+        advanced?: pulumi.Input<inputs.tls.RuleUserDefineRuleAdvanced>;
+        /**
+         * Whether to upload the label information of the host group to the log service. The default is off. 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): Host group label information is not uploaded.
+         */
+        enableHostGroupLabel?: pulumi.Input<boolean>;
+        /**
+         * Upload the hostname field. Default is disabled. true: Add a field to the original log to record the source hostname. Specify the hostname field name using HostnameKey. false: (default) Do not add the hostname field.
+         */
+        enableHostname?: pulumi.Input<boolean>;
+        /**
+         * 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.RuleUserDefineRuleField>[]>;
+        /**
+         * Field name used to store machine group label information
+         */
+        hostGroupLabelKey?: pulumi.Input<string>;
+        /**
+         * Hostname field name. Required only when EnableHostname is true.
+         */
+        hostnameKey?: pulumi.Input<string>;
         /**
-         * Case sensitivity. true: Case sensitive. false: Not case sensitive.
+         * Ignore log files that have not been updated for a specified period (in hours).
          */
-        caseSensitive?: pulumi.Input<boolean>;
+        ignoreOlder?: pulumi.Input<number>;
         /**
-         * Token separators for the full-text index. Each character in the string represents a token separator. Length: 1–256 bytes. Only one or more of the following characters are supported: letters, numbers, and !@#%^&*()-_=\\"', <>/?|;:\	\r[]{}. . Supports configuring both Chinese characters and token separators simultaneously.
+         * Allow multiple log file collections. Empty: Use log file ID (including file inode, device, and checksum of the first N bytes) to uniquely identify the log file. RuleID: Use collection rule ID and log file ID to uniquely identify the log file. TopicIDRuleName: Use log topic ID, collection rule name, and log file ID to uniquely identify the log file.
          */
-        delimiter?: pulumi.Input<string>;
+        multiCollectsType?: pulumi.Input<string>;
         /**
-         * When searching, specify whether to segment Chinese content in logs according to Chinese grammar. The default is false. true: For Chinese characters in logs, segment the log according to common Chinese grammar rules. Custom segmentation symbols for Chinese content are not supported. For non-Chinese characters in logs, segment the log using the segmentation symbols specified in the parameter. false: Segment the log using the segmentation symbols specified in the parameter.
+         * Rule for parsing the collection path. After setting the rule, fields in the collection path are extracted using the specified regular expression and added as metadata to the log data. Note: This parameter is not supported when collecting container standard output.
          */
-        includeChinese?: pulumi.Input<boolean>;
-    }
-    interface IndexKeyValue {
+        parsePathRule?: pulumi.Input<inputs.tls.RuleUserDefineRuleParsePathRule>;
         /**
-         * Specify the field names for key-value indexing. Up to 100 fields can be added. Only letters, numbers, spaces, underscores (_), hyphens (-), and slashes (/) are supported, and field names cannot start or end with a space. Each key name must be unique within the same index. Length: 1–128 characters. For subfields in JSON-type key-value indexes, use a dot (.) to indicate the hierarchy between JSON fields. For example, if the JSON field 'namelist' contains a text-type subfield 'totalcount' and a JSON-type subfield 'info', and 'info' contains the field 'name', the field names should be configured as 'totalcount' and 'info.name' respectively.
+         * LogCollector plugin configuration. After enabling plugin configuration, you can add one or more LogCollector processor plugins to parse logs with complex or variable structures.
          */
-        key?: pulumi.Input<string>;
+        plugin?: pulumi.Input<inputs.tls.RuleUserDefineRulePlugin>;
         /**
-         * Field description information required for configuring key-value indexes.
+         * Name of the raw log field. 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 along with the parsed log data.
          */
-        value?: pulumi.Input<inputs.tls.IndexKeyValueValue>;
-    }
-    interface IndexKeyValueValue {
+        rawLogKey?: pulumi.Input<string>;
         /**
-         * Indicates whether the index was added automatically. true: The index was added automatically. false: The index was not added automatically.
+         * 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 this parameter is set, logs are collected using the HashKey routing Shard mode, and the log service writes data to the Shard containing the specified Key value
          */
-        autoIndexFlag?: pulumi.Input<boolean>;
+        shardHashKey?: pulumi.Input<inputs.tls.RuleUserDefineRuleShardHashKey>;
         /**
-         * Whether to distinguish case. Default is false.
+         * LogCollector collection policy, which specifies whether LogCollector collects incremental logs or full logs. Default is false, meaning full log collection. true: incremental collection. LogCollector only collects newly added content in the file. When new logs are written to monitored log files, LogCollector triggers log collection. For first-time collection, 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 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, collecting only incremental logs. For subsequent collections, LogCollector determines the collection position based on Checkpoint and continues collecting. false: (default) full collection. LogCollector collects logs from the beginning of each file, including historical log data.
          */
-        caseSensitive?: pulumi.Input<boolean>;
+        tailFiles?: pulumi.Input<boolean>;
         /**
-         * Token separators for the field. Default is empty (""). Each character in the string represents a token separator. Length: 0–256 bytes. If the length is 0, segmentation is disabled. Only one or more of the following characters are supported: letters, numbers, and !@#%^&*()-_=\\"', <>/?|;:\	\r[]{}. . Supports configuring both Chinese characters and token separators simultaneously.
+         * Backtracking threshold for incremental collection, 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 that is TailSizeKb from the end of the file.
          */
-        delimiter?: pulumi.Input<string>;
+        tailSizeKb?: pulumi.Input<number>;
+    }
+    interface RuleUserDefineRuleAdvanced {
         /**
-         * When searching, determines whether to segment Chinese log content according to Chinese syntax. Enabled: Chinese characters in logs are segmented based on common Chinese syntax; custom segmentation for Chinese content is not supported. Non-Chinese characters in logs are segmented using the token separators specified in the parameter. Disabled: Logs are segmented using the token separators specified in the parameter.
+         * After reading to the end of the log file, choose whether to release the file handle. Default is false.
          */
-        includeChinese?: pulumi.Input<boolean>;
+        closeEof?: pulumi.Input<boolean>;
         /**
-         * Create indexes for all fields with text values in the JSON field.
+         * Wait time to release log file handle. If no new logs are written to the log file within the specified time, the handle for that log file is released. Unit: seconds. Range: 1–300 seconds. Default: 60 seconds.
          */
-        indexAll?: pulumi.Input<boolean>;
+        closeInactive?: pulumi.Input<number>;
         /**
-         * Enable automatic indexing and statistics for JSON fields. true: Enable automatic indexing and statistics. false: Disable automatic indexing and statistics.
+         * Release the file handle after the log file is removed. Default is false.
          */
-        indexSqlAll?: pulumi.Input<boolean>;
-        jsonKeys?: pulumi.Input<pulumi.Input<inputs.tls.IndexKeyValueValueJsonKey>[]>;
+        closeRemoved?: pulumi.Input<boolean>;
         /**
-         * Whether analysis is enabled for the field. Default is false. After enabling statistical analysis, you can configure token delimiters and whether to include Chinese content.
+         * Release the file handle after the log file is renamed. Default is false.
          */
-        sqlFlag?: pulumi.Input<boolean>;
+        closeRenamed?: pulumi.Input<boolean>;
         /**
-         * Field type. Currently supports long, double, text, and json. The long and double types do not support configuring delimiters, including Chinese, or case sensitivity. Only the json type supports further configuration of JsonKeys subfields.
+         * Maximum monitoring duration for LogCollector log files, in seconds. The default is 0 seconds, meaning LogCollector does not limit the monitoring duration for log files. Timing starts when LogCollector begins monitoring the log file. Once the specified duration is exceeded, LogCollector immediately releases the file handle and stops monitoring, regardless of whether the log file has been fully read.
          */
-        valueType?: pulumi.Input<string>;
+        closeTimeout?: pulumi.Input<number>;
+        /**
+         * Maximum wait time when LogCollector does not detect a line break, in seconds. The default is 5s. Timing starts when LogCollector begins reading the log file. If no line break is detected within the specified time, LogCollector sends the logs in the buffer. If the file write interval is long, 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 IndexKeyValueValueJsonKey {
+    interface RuleUserDefineRuleField {
         /**
-         * Specify the field names for key-value indexing. Up to 100 fields can be added. Only letters, numbers, spaces, underscores (_), hyphens (-), and slashes (/) are supported, and field names cannot start or end with a space. Each key name must be unique within the same index. Length: 1–128 characters. For subfields in JSON-type key-value indexes, use a dot (.) to indicate the hierarchy between JSON fields. For example, if the JSON field 'namelist' contains a text-type subfield 'totalcount' and a JSON-type subfield 'info', and 'info' contains the field 'name', the field names should be configured as 'totalcount' and 'info.name' respectively.
+         * Key.
          */
         key?: pulumi.Input<string>;
         /**
-         * Field description information required for configuring key-value indexes.
+         * Value.
          */
-        value?: pulumi.Input<inputs.tls.IndexKeyValueValueJsonKeyValue>;
+        val?: pulumi.Input<string>;
     }
-    interface IndexKeyValueValueJsonKeyValue {
+    interface RuleUserDefineRuleParsePathRule {
         /**
-         * Indicates whether the index was added automatically. true: The index was added automatically. false: The index was not added automatically.
+         * Field name list. The log service uses a regular expression (Regex) to parse the path sample (PathSample) into multiple fields. Keys specify the name of each field. You can configure up to 100 field names. Field names cannot be empty or duplicated.
          */
-        autoIndexFlag?: pulumi.Input<boolean>;
+        keys?: pulumi.Input<pulumi.Input<string>[]>;
         /**
-         * Create indexes for all fields with text values in the JSON field.
+         * Sample collection path for actual scenarios. The sample collection path must be an absolute path. Wildcards *, ?, ** are not allowed in the path sample.
          */
-        indexAll?: pulumi.Input<boolean>;
+        pathSample?: pulumi.Input<string>;
         /**
-         * Enable automatic indexing and statistics for JSON fields. true: Enable automatic indexing and statistics. false: Disable automatic indexing and statistics.
+         * Regular expression used to extract the path field. Must match the sample collection path, otherwise extraction will fail
          */
-        indexSqlAll?: pulumi.Input<boolean>;
+        regex?: pulumi.Input<string>;
+    }
+    interface RuleUserDefineRulePlugin {
         /**
-         * Whether analysis is enabled for the field. Default is false. After enabling statistical analysis, you can configure token delimiters and whether to include Chinese content.
+         * LogCollector plugin. For the list of supported plugins and parameter descriptions, see LogCollector plugin overview.
          */
-        sqlFlag?: pulumi.Input<boolean>;
+        processors?: pulumi.Input<string>;
+    }
+    interface RuleUserDefineRuleShardHashKey {
         /**
-         * Field type. Currently supports long, double, text, and json. The long and double types do not support configuring delimiters, including Chinese, or case sensitivity. Only the json type supports further configuration of JsonKeys subfields.
+         * HashKey of the log group, used to specify the shard to which the current log group will be written. The value range for this parameter is [00000000000000000000000000000000-ffffffffffffffffffffffffffffffff).
          */
-        valueType?: pulumi.Input<string>;
+        hashKey?: pulumi.Input<string>;
     }
-    interface IndexUserInnerKeyValue {
+    interface ScheduleSqlTaskRequestCycle {
         /**
-         * Specify the field names for key-value indexing. Up to 100 fields can be added. Only letters, numbers, spaces, underscores (_), hyphens (-), and slashes (/) are supported, and field names cannot start or end with a space. Each key name must be unique within the same index. Length: 1–128 characters. For subfields in JSON-type key-value indexes, use a dot (.) to indicate the hierarchy between JSON fields. For example, if the JSON field 'namelist' contains a text-type subfield 'totalcount' and a JSON-type subfield 'info', and 'info' contains the field 'name', the field names should be configured as 'totalcount' and 'info.name' respectively.
+         * Cron expression, with a minimum granularity of minutes, using 24-hour format. For example, 0 18 * * * means execution at 18:00 every day.
          */
-        key?: pulumi.Input<string>;
+        cronTab?: pulumi.Input<string>;
         /**
-         * Field description information required for configuring key-value indexes.
+         * If Type is set to Cron, you must also set the time zone.
          */
-        value?: pulumi.Input<inputs.tls.IndexUserInnerKeyValueValue>;
+        cronTimeZone?: pulumi.Input<string>;
+        /**
+         * Scheduling period or the time point for periodic execution (minutes from 00:00). Range: 1–1440 minutes.
+         */
+        time: pulumi.Input<number>;
+        /**
+         * Scheduling period type. Options: Period, Fixed, Cron.
+         */
+        type: pulumi.Input<string>;
     }
-    interface IndexUserInnerKeyValueValue {
+    interface ShipperContentInfo {
         /**
-         * Indicates whether the index was added automatically. true: The index was added automatically. false: The index was not added automatically.
+         * CSV format log content configuration.
          */
-        autoIndexFlag?: pulumi.Input<boolean>;
+        csvInfo?: pulumi.Input<inputs.tls.ShipperContentInfoCsvInfo>;
         /**
-         * Whether to distinguish case. Default is false.
+         * Log content parsing format. Delivery to TOS supports json, jsonl, csv; delivery to Kafka supports original, json.
          */
-        caseSensitive?: pulumi.Input<boolean>;
+        format?: pulumi.Input<string>;
         /**
-         * Token separators for the field. Default is empty (""). Each character in the string represents a token separator. Length: 0–256 bytes. If the length is 0, segmentation is disabled. Only one or more of the following characters are supported: letters, numbers, and !@#%^&*()-_=\\"', <>/?|;:\	\r[]{}. . Supports configuring both Chinese characters and token separators simultaneously.
+         * JSON/JSONL format log content configuration.
          */
-        delimiter?: pulumi.Input<string>;
+        jsonInfo?: pulumi.Input<inputs.tls.ShipperContentInfoJsonInfo>;
+    }
+    interface ShipperContentInfoCsvInfo {
         /**
-         * When searching, determines whether to segment Chinese log content according to Chinese syntax. Enabled: Chinese characters in logs are segmented based on common Chinese syntax; custom segmentation for Chinese content is not supported. Non-Chinese characters in logs are segmented using the token separators specified in the parameter. Disabled: Logs are segmented using the token separators specified in the parameter.
+         * Delimiter. Supports comma, tab, pipe, semicolon, space.
          */
-        includeChinese?: pulumi.Input<boolean>;
+        delimiter?: pulumi.Input<string>;
         /**
-         * Create indexes for all fields with text values in the JSON field.
+         * Escape character. When field content contains a delimiter, use an escape character to enclose it. Supports single quote, double quote, or empty character.
          */
-        indexAll?: pulumi.Input<boolean>;
+        escapeChar?: pulumi.Input<string>;
         /**
-         * Enable automatic indexing and statistics for JSON fields. true: Enable automatic indexing and statistics. false: Disable automatic indexing and statistics.
+         * Fields to be delivered. Supports letters, numbers, and _-./. Cannot start with an underscore. Length: 1–128.
          */
-        indexSqlAll?: pulumi.Input<boolean>;
-        jsonKeys?: pulumi.Input<pulumi.Input<inputs.tls.IndexUserInnerKeyValueValueJsonKey>[]>;
+        keys?: pulumi.Input<pulumi.Input<string>[]>;
         /**
-         * Whether analysis is enabled for the field. Default is false. After enabling statistical analysis, you can configure token delimiters and whether to include Chinese content.
+         * Content for invalid field padding. Length: 0–128.
          */
-        sqlFlag?: pulumi.Input<boolean>;
+        nonFieldContent?: pulumi.Input<string>;
         /**
-         * Field type. Currently supports long, double, text, and json. The long and double types do not support configuring delimiters, including Chinese, or case sensitivity. Only the json type supports further configuration of JsonKeys subfields.
+         * Whether to print the key in the first row.
          */
-        valueType?: pulumi.Input<string>;
+        printHeader?: pulumi.Input<boolean>;
     }
-    interface IndexUserInnerKeyValueValueJsonKey {
+    interface ShipperContentInfoJsonInfo {
         /**
-         * Specify the field names for key-value indexing. Up to 100 fields can be added. Only letters, numbers, spaces, underscores (_), hyphens (-), and slashes (/) are supported, and field names cannot start or end with a space. Each key name must be unique within the same index. Length: 1–128 characters. For subfields in JSON-type key-value indexes, use a dot (.) to indicate the hierarchy between JSON fields. For example, if the JSON field 'namelist' contains a text-type subfield 'totalcount' and a JSON-type subfield 'info', and 'info' contains the field 'name', the field names should be configured as 'totalcount' and 'info.name' respectively.
+         * Enable flag.
          */
-        key?: pulumi.Input<string>;
+        enable?: pulumi.Input<boolean>;
         /**
-         * Field description information required for configuring key-value indexes.
+         * Whether to enable escaping. Must be set to true.
          */
-        value?: pulumi.Input<inputs.tls.IndexUserInnerKeyValueValueJsonKeyValue>;
+        escape?: pulumi.Input<boolean>;
+        /**
+         * Delivery field list; if not configured, all fields will be delivered. When delivering in JSON/JSONL format, if this parameter is not set, all fields will be delivered, including **content** (required), **source**, **path**, **time**, **image_name**, **container_name**, **pod_name**, **pod_uid**, namespace, **tag****client_ip**, and **tag****receive_time**.
+         */
+        keys?: pulumi.Input<pulumi.Input<string>[]>;
     }
-    interface IndexUserInnerKeyValueValueJsonKeyValue {
+    interface ShipperKafkaShipperInfo {
         /**
-         * Indicates whether the index was added automatically. true: The index was added automatically. false: The index was not added automatically.
+         * Compression format; supports snappy, gzip, lz4, none.
          */
-        autoIndexFlag?: pulumi.Input<boolean>;
+        compress?: pulumi.Input<string>;
         /**
-         * Create indexes for all fields with text values in the JSON field.
+         * Delivery end time, in milliseconds. If not set, delivery continues indefinitely. Note: Milliseconds will be truncated. For example, if 1776761323455 is entered, it will become 1776761323000; if 1776761323 is entered, it will become 1776761323000.
          */
-        indexAll?: pulumi.Input<boolean>;
+        endTime?: pulumi.Input<number>;
         /**
-         * Enable automatic indexing and statistics for JSON fields. true: Enable automatic indexing and statistics. false: Disable automatic indexing and statistics.
+         * Kafka instance.
          */
-        indexSqlAll?: pulumi.Input<boolean>;
+        instance?: pulumi.Input<string>;
         /**
-         * Whether analysis is enabled for the field. Default is false. After enabling statistical analysis, you can configure token delimiters and whether to include Chinese content.
+         * Kafka topic name. All log data delivered through this configuration will be sent to this topic.
          */
-        sqlFlag?: pulumi.Input<boolean>;
+        kafkaTopic?: pulumi.Input<string>;
         /**
-         * Field type. Currently supports long, double, text, and json. The long and double types do not support configuring delimiters, including Chinese, or case sensitivity. Only the json type supports further configuration of JsonKeys subfields.
+         * Start time. If not configured, defaults to the current time. Note: Millisecond data will be ignored. For example, if 1776761323455 is entered, the result will be 1776761323000; if 1776761323 is entered, the result will be 1776761323000.
          */
-        valueType?: pulumi.Input<string>;
+        startTime?: pulumi.Input<number>;
     }
-    interface ProjectTag {
+    interface ShipperTosShipperInfo {
         /**
-         * Tag key
+         * Select a TOS bucket. Must be in the same region as the source log topic. Can only contain numbers, hyphens (-), and letters a–z. Must start and end with a number or letter. Length: 3–63 characters.
          */
-        key?: pulumi.Input<string>;
+        bucket?: pulumi.Input<string>;
         /**
-         * Tag value
+         * Compression format; supports snappy, gzip, lz4, none.
          */
-        value?: pulumi.Input<string>;
-    }
-    interface ScheduleSqlTaskRequestCycle {
+        compress?: pulumi.Input<string>;
         /**
-         * Cron expression, with a minimum granularity of minutes, using 24-hour format. For example, 0 18 * * * means execution at 18:00 every day.
+         * Delivery interval in seconds, range: 300–900.
          */
-        cronTab?: pulumi.Input<string>;
+        interval?: pulumi.Input<number>;
         /**
-         * If Type is set to Cron, you must also set the time zone.
+         * Maximum raw file size per partition for delivery, in MiB. Range: 5–256.
          */
-        cronTimeZone?: pulumi.Input<string>;
+        maxSize?: pulumi.Input<number>;
         /**
-         * Scheduling period or the time point for periodic execution (minutes from 00:00). Range: 1–1440 minutes.
+         * Partition rule for log delivery. Subdirectory naming format supports strftime syntax. Default: %Y/%m/%d/%H/%M.
          */
-        time: pulumi.Input<number>;
+        partitionFormat?: pulumi.Input<string>;
         /**
-         * Scheduling period type. Options: Period, Fixed, Cron.
+         * Top-level directory name for the bucket. Cannot start with / or \, and cannot use consecutive /. Cannot use .. as a folder name. Duplicate names are not allowed within the same bucket.
          */
-        type: pulumi.Input<string>;
+        prefix?: pulumi.Input<string>;
     }
     interface TopicTag {
         /**
@@ -8957,6 +10401,52 @@ export declare namespace tos {
          */
         ownerId?: pulumi.Input<string>;
     }
+    interface BucketInventoryDestination {
+        /**
+         * Bucket information related to the inventory files.
+         */
+        tosBucketDestination?: pulumi.Input<inputs.tos.BucketInventoryDestinationTosBucketDestination>;
+    }
+    interface BucketInventoryDestinationTosBucketDestination {
+        /**
+         * Account ID of the bucket owner.
+         */
+        accountId?: pulumi.Input<string>;
+        /**
+         * Specify the bucket to store the inventory files.
+         */
+        bucket?: pulumi.Input<string>;
+        /**
+         * Inventory file format. Value is CSV, meaning the inventory file is in CSV format compressed with GZIP.
+         */
+        format?: pulumi.Input<string>;
+        /**
+         * Prefix for the storage path of inventory files. By default, files are saved under tos*bucket*inventory/sourceBucketName/inventoryId/YYYY-MM-DDTHH-MMZ/files in the target bucket.
+         */
+        prefix?: pulumi.Input<string>;
+        /**
+         * Role name used to grant permission to read all files from the source bucket and write files to the target bucket. The role must have TOS read/write and service access permissions. You can also use the default TOS role TosArchiveTOSInventory.
+         */
+        role?: pulumi.Input<string>;
+    }
+    interface BucketInventoryFilter {
+        /**
+         * Prefix matching information for exported files. If not set, an inventory of all objects in the bucket is generated by default.
+         */
+        prefix?: pulumi.Input<string>;
+    }
+    interface BucketInventoryOptionalFields {
+        /**
+         * Information about exported inventory files.
+         */
+        fields?: pulumi.Input<pulumi.Input<string>[]>;
+    }
+    interface BucketInventorySchedule {
+        /**
+         * Export frequency for inventory files. Options: Daily: export inventory files daily. Weekly: export inventory files weekly. Once: export inventory files once.
+         */
+        frequency?: pulumi.Input<string>;
+    }
     interface BucketLifecycleConfig {
         /**
          * Specify expiration attributes for unmerged multipart tasks (fragments)
@@ -9238,6 +10728,58 @@ export declare namespace vedbm {
          */
         accountPrivilegeDetails?: pulumi.Input<pulumi.Input<string>[]>;
     }
+    interface EndpointPrivateAddresses {
+        /**
+         * Resolution method, fixed as false
+         */
+        dnsVisibility?: pulumi.Input<boolean>;
+        /**
+         * Instance intranet access domain name
+         */
+        domain?: pulumi.Input<string>;
+        /**
+         * Public network ID
+         */
+        eipId?: pulumi.Input<string>;
+        /**
+         * IP address
+         */
+        ipAddress?: pulumi.Input<string>;
+        /**
+         * Network type
+         */
+        networkType?: pulumi.Input<string>;
+        /**
+         * Subnet ID
+         */
+        subnetId?: pulumi.Input<string>;
+    }
+    interface EndpointPublicAddresses {
+        /**
+         * Resolution method, fixed as false
+         */
+        dnsVisibility?: pulumi.Input<boolean>;
+        /**
+         * Instance intranet access domain name
+         */
+        domain?: pulumi.Input<string>;
+        /**
+         * Public network ID
+         */
+        eipId?: pulumi.Input<string>;
+        /**
+         * IP address
+         */
+        ipAddress?: pulumi.Input<string>;
+        /**
+         * Network type
+         */
+        networkType?: pulumi.Input<string>;
+        /**
+         * Subnet ID
+         */
+        subnetId?: pulumi.Input<string>;
+    }
     interface InstanceChargeDetail {
         /**
          * Whether to enable auto-renewal in prepaid scenarios. Values: true: auto-renewal. false: no auto-renewal.
@@ -9380,10 +10922,30 @@ export declare namespace vedbm {
          * Node failover priority. Range: 0~15. Higher values indicate higher priority
          */
         failoverPriority?: pulumi.Input<number>;
+        /**
+         * Memory size, in GiB.
+         */
+        memory?: pulumi.Input<number>;
+        /**
+         * Node ID
+         */
+        nodeId?: pulumi.Input<string>;
+        /**
+         * Node specification.
+         */
+        nodeSpec?: pulumi.Input<string>;
         /**
          * Node type. Values: Primary: primary node. ReadOnly: read-only node.
          */
         nodeType?: pulumi.Input<string>;
+        /**
+         * CPU size. For example, a value of 1 indicates a CPU size of 1U.
+         */
+        vCpu?: pulumi.Input<number>;
+        /**
+         * Availability zone ID
+         */
+        zoneId?: pulumi.Input<string>;
     }
     interface InstanceTag {
         /**
@@ -9666,6 +11228,38 @@ export declare namespace vepfs {
          */
         value?: pulumi.Input<string>;
     }
+    interface MountServiceAttachFileSystem {
+        /**
+         * Account ID.
+         */
+        accountId?: pulumi.Input<string>;
+        /**
+         * User mount path.
+         */
+        customerPath?: pulumi.Input<string>;
+        /**
+         * File system ID.
+         */
+        fileSystemId?: pulumi.Input<string>;
+        /**
+         * File system name.
+         */
+        fileSystemName?: pulumi.Input<string>;
+        /**
+         * Binding status. Details: Attaching: Attaching. AttachError: Attachment failed. Attached: Attached. Detaching: Detaching. DetachError: Detachment failed.
+         */
+        status?: pulumi.Input<string>;
+    }
+    interface MountServiceNode {
+        /**
+         * Node initial password.
+         */
+        defaultPassword?: pulumi.Input<string>;
+        /**
+         * Node instance ID.
+         */
+        nodeId?: pulumi.Input<string>;
+    }
 }
 export declare namespace vke {
     interface AddonStatus {
@@ -11870,6 +13464,10 @@ export declare namespace vpn {
         value?: pulumi.Input<string>;
     }
     interface VpnConnectionTunnelOption {
+        /**
+         * IPsec tunnel status. ike*sa*negotiation*failed: Phase one negotiation failed; nike*sa*negotiation*completed: Phase one negotiation succeeded; nipsec*sa*negotiation*failed: Phase two negotiation failed; nipsec*sa*negotiation*completed: Phase two negotiation succeeded.
+         */
+        connectStatus?: pulumi.Input<string>;
         /**
          * ID of the customer gateway associated with the IPsec connection.
          */
@@ -11960,10 +13558,30 @@ export declare namespace vpn {
         lifetime?: pulumi.Input<number>;
     }
     interface VpnConnectionTunnelOptionTunnelBgpInfo {
+        /**
+         * Enable dynamic route propagation. false (default): No, use static routing mode. true: Yes, use BGP routing mode.
+         */
+        enableBgp?: pulumi.Input<boolean>;
+        /**
+         * The ASN of the VPN gateway.
+         */
+        localAsn?: pulumi.Input<number>;
         /**
          * BGP address. Defaults to the first host address of TunnelOptions.N.BGPConfig.TunnelCidr. This address must be an IP address within the IPsec tunnel CIDR block. If EnableTunnelsBgp is set to true, this parameter must be specified.
          */
         localBgpIp?: pulumi.Input<string>;
+        /**
+         * ASN of the customer gateway.
+         */
+        peerAsn?: pulumi.Input<number>;
+        /**
+         * BGP peer IP, that is, the BGP address on the customer gateway side.
+         */
+        peerBgpIp?: pulumi.Input<string>;
+        /**
+         * Status of the BGP connection. Up: BGP connection is normal. Down: BGP connection is not working.
+         */
+        sessionStatus?: pulumi.Input<string>;
         /**
          * The CIDR address range for the local and peer IPs of the BGP session. This range must be within the 169.254.0.0/16 subnet with a subnet mask length of 30. If EnableTunnelsBgp is set to true, this parameter must be provided.
          */