@volcengine/pulumi-volcenginecc 0.0.42 → 0.0.44

package/types/output.d.ts

@@ -9802,6 +9802,36 @@ export declare namespace cr {
          */
         value: string;
     }
+    interface GetVpcEndpointVpc {
+        /**
+         * Primary account ID for the VPC
+         */
+        accountId: number;
+        /**
+         * Creation time
+         */
+        createTime: string;
+        /**
+         * IP address of the image repository within the VPC
+         */
+        ip: string;
+        /**
+         * VPC region
+         */
+        region: string;
+        /**
+         * Access endpoint status: Enabling: in progress. Enabled: enabled. Disabling: in progress. Failed: failed.
+         */
+        status: string;
+        /**
+         * Subnet ID
+         */
+        subnetId: string;
+        /**
+         * VPC ID。
+         */
+        vpcId: string;
+    }
     interface RegistryEndpoint {
         aclPolicies: outputs.cr.RegistryEndpointAclPolicy[];
         /**
@@ -9849,6 +9879,20 @@ export declare namespace cr {
          */
         value: string;
     }
+    interface VpcEndpointVpc {
+        /**
+         * Primary account ID for the VPC
+         */
+        accountId: number;
+        /**
+         * Subnet ID
+         */
+        subnetId: string;
+        /**
+         * VPC ID。
+         */
+        vpcId: string;
+    }
 }
 export declare namespace directconnect {
     interface DirectConnectGatewayAssociateCen {
@@ -14094,6 +14138,22 @@ export declare namespace fwcenter {
     }
 }
 export declare namespace gtm {
+    interface GetPolicyStatistics {
+        /**
+         * Number of available addresses
+         */
+        activeAddr: number;
+        /**
+         * Number of unavailable addresses
+         */
+        inactiveAddr: number;
+    }
+    interface GetPolicyTarget {
+        /**
+         * Address pool ID.
+         */
+        poolId: string;
+    }
     interface GetPoolAddress {
         /**
          * Address capacity
@@ -14270,6 +14330,22 @@ export declare namespace gtm {
          */
         operator: string;
     }
+    interface PolicyStatistics {
+        /**
+         * Number of available addresses
+         */
+        activeAddr: number;
+        /**
+         * Number of unavailable addresses
+         */
+        inactiveAddr: number;
+    }
+    interface PolicyTarget {
+        /**
+         * Address pool ID.
+         */
+        poolId: string;
+    }
     interface PoolAddress {
         /**
          * Address capacity
@@ -14501,6 +14577,26 @@ export declare namespace hbase {
     }
 }
 export declare namespace iam {
+    interface AllowedIpAddressIpList {
+        /**
+         * Description
+         */
+        description: string;
+        /**
+         * IP address
+         */
+        ip: string;
+    }
+    interface GetAllowedIpAddressIpList {
+        /**
+         * Description
+         */
+        description: string;
+        /**
+         * IP address
+         */
+        ip: string;
+    }
     interface GetGroupAttachedPolicy {
         /**
          * Policy binding time.
@@ -15518,6 +15614,16 @@ export declare namespace kafka {
          */
         instanceName: string;
     }
+    interface GetGroupTag {
+        /**
+         * Tag key
+         */
+        key: string;
+        /**
+         * Tag value
+         */
+        value: string;
+    }
     interface GetInstanceChargeInfo {
         /**
          * Whether to automatically renew the subscription instance after expiration. true   - auto renewal; false (default)   - no auto renewal, instance will be stopped upon expiration.
@@ -15604,6 +15710,16 @@ export declare namespace kafka {
          */
         value: string;
     }
+    interface GroupTag {
+        /**
+         * Tag key
+         */
+        key: string;
+        /**
+         * Tag value
+         */
+        value: string;
+    }
     interface InstanceChargeInfo {
         /**
          * Whether to automatically renew the subscription instance after expiration. true   - auto renewal; false (default)   - no auto renewal, instance will be stopped upon expiration.
@@ -16012,6 +16128,49 @@ export declare namespace mongodb {
          */
         vpc: string;
     }
+    interface EndpointDbAddress {
+        /**
+         * Domain name of the connection address
+         */
+        addressDomain: string;
+        /**
+         * IP corresponding to the connection address
+         */
+        addressIp: string;
+        /**
+         * Port number of the connection address
+         */
+        addressPort: string;
+        /**
+         * Connection address type of the node. Possible values:
+         *
+         *   Primary: Primary node connection address
+         *   Secondary: Secondary node connection address
+         *   Hidden: Hidden node connection address
+         *   ReadOnly: Read-only node connection address
+         *
+         *
+         *   **Note:**
+         *   Hidden node connection address information is returned only when the connection address type is a private connection address (that is, when `NetworkType` is set to `Private`).
+         */
+        addressType: string;
+        /**
+         * EIP ID bound to the instance's public address
+         *
+         *
+         *   **Note:**
+         *   This parameter is returned only when the connection address type is a public connection address (that is, when `NetworkType` is set to `Public`).
+         */
+        eipId: string;
+        /**
+         * Node ID associated with the connection address
+         */
+        nodeId: string;
+        /**
+         * AZ of the node; all nodes are consistent for single-AZ instances, while nodes differ for multi-AZ instances
+         */
+        zoneId: string;
+    }
     interface GetAccountAccountPrivilege {
         /**
          * Databases for which the account has permissions.
@@ -16040,6 +16199,53 @@ export declare namespace mongodb {
          */
         vpc: string;
     }
+    interface GetEndpointDbAddress {
+        /**
+         * Domain name of the connection address
+         */
+        addressDomain: string;
+        /**
+         * IP corresponding to the connection address
+         *
+         *
+         *   **Note:**
+         *   It is not recommended to connect to the instance using the `IP:port` format, as the IP address may change after switching subnets. If the client code is not updated in time, instance connection failures may occur. We recommend accessing the MongoDB instance using the `domain:port` format to avoid connection issues caused by IP address changes. For detailed steps to connect to a MongoDB instance, see Connect to an Instance Using the Mongo Shell Tool.
+         */
+        addressIp: string;
+        /**
+         * Port number of the connection address
+         */
+        addressPort: string;
+        /**
+         * Connection address type of the node. Possible values:
+         *
+         *   Primary: Primary node connection address
+         *   Secondary: Secondary node connection address
+         *   Hidden: Hidden node connection address
+         *   ReadOnly: Read-only node connection address
+         *
+         *
+         *   **Note:**
+         *   Hidden node connection address information is returned only when the connection address type is a private connection address (that is, when `NetworkType` is set to `Private`).
+         */
+        addressType: string;
+        /**
+         * EIP ID bound to the instance's public address
+         *
+         *
+         *   **Note:**
+         *   This parameter is returned only when the connection address type is a public connection address (that is, when `NetworkType` is set to `Public`).
+         */
+        eipId: string;
+        /**
+         * Node ID associated with the connection address
+         */
+        nodeId: string;
+        /**
+         * AZ of the node; all nodes are consistent for single-AZ instances, while nodes differ for multi-AZ instances
+         */
+        zoneId: string;
+    }
     interface GetInstanceConfigServer {
         /**
          * ConfigServer node ID
@@ -16785,6 +16991,16 @@ export declare namespace privatelink {
          */
         value: string;
     }
+    interface GatewayEndpointTag {
+        /**
+         * Tag key of the endpoint tag
+         */
+        key: string;
+        /**
+         * Tag value of the endpoint tag
+         */
+        value: string;
+    }
     interface GetEndpointServicePrivateDnsNameConfiguration {
         /**
          * Domain verification name.
@@ -16827,6 +17043,16 @@ export declare namespace privatelink {
          */
         value: string;
     }
+    interface GetGatewayEndpointTag {
+        /**
+         * Tag key of the endpoint tag
+         */
+        key: string;
+        /**
+         * Tag value of the endpoint tag
+         */
+        value: string;
+    }
     interface GetVpcEndpointConnectionResourcesAllocate {
         /**
          * Specify the service resource for the endpoint connection
@@ -17555,6 +17781,58 @@ export declare namespace rdsmssql {
          */
         vpc: string;
     }
+    interface BackupBackupDatabaseDetail {
+        /**
+         * External network backup download link.
+         */
+        backupDownloadLinkEip: string;
+        /**
+         * Internal network backup download link.
+         */
+        backupDownloadLinkInner: string;
+        /**
+         * Backup end time. Format: yyyy-MM-ddTHH:mm:ss.sZ (UTC time).
+         */
+        backupEndTime: string;
+        /**
+         * Backup file name.
+         */
+        backupFileName: string;
+        /**
+         * Backup file size (Bytes).
+         */
+        backupFileSize: number;
+        /**
+         * Backup start time. Format: yyyy-MM-ddTHH:mm:ss.sZ (UTC time).
+         */
+        backupStartTime: string;
+        /**
+         * Backup type. Values: Full (full backup), Diff (differential backup).
+         */
+        backupType: string;
+        /**
+         * Database name.
+         */
+        databaseName: string;
+        /**
+         * Backup file preparation progress (%).
+         */
+        downloadProgress: number;
+        /**
+         * Backup file preparation status. Values: Success (preparation completed), Failed (preparation failed), Running (preparing), NotDownload (not downloaded).
+         */
+        downloadStatus: string;
+        /**
+         * Download link expiration time. Format: yyyy-MM-ddTHH:mm:sssZ (UTC time).
+         */
+        linkExpiredTime: string;
+    }
+    interface BackupBackupMeta {
+        /**
+         * Backup database name.
+         */
+        dbName: string;
+    }
     interface GetAllowListAssociatedInstance {
         /**
          * Instance ID
@@ -17581,6 +17859,58 @@ export declare namespace rdsmssql {
          */
         vpc: string;
     }
+    interface GetBackupBackupDatabaseDetail {
+        /**
+         * External network backup download link.
+         */
+        backupDownloadLinkEip: string;
+        /**
+         * Internal network backup download link.
+         */
+        backupDownloadLinkInner: string;
+        /**
+         * Backup end time. Format: yyyy-MM-ddTHH:mm:ss.sZ (UTC time).
+         */
+        backupEndTime: string;
+        /**
+         * Backup file name.
+         */
+        backupFileName: string;
+        /**
+         * Backup file size (Bytes).
+         */
+        backupFileSize: number;
+        /**
+         * Backup start time. Format: yyyy-MM-ddTHH:mm:ss.sZ (UTC time).
+         */
+        backupStartTime: string;
+        /**
+         * Backup type. Values: Full (full backup), Diff (differential backup).
+         */
+        backupType: string;
+        /**
+         * Database name.
+         */
+        databaseName: string;
+        /**
+         * Backup file preparation progress (%).
+         */
+        downloadProgress: number;
+        /**
+         * Backup file preparation status. Values: Success (preparation completed), Failed (preparation failed), Running (preparing), NotDownload (not downloaded).
+         */
+        downloadStatus: string;
+        /**
+         * Download link expiration time. Format: yyyy-MM-ddTHH:mm:sssZ (UTC time).
+         */
+        linkExpiredTime: string;
+    }
+    interface GetBackupBackupMeta {
+        /**
+         * Backup database name.
+         */
+        dbName: string;
+    }
     interface GetInstanceChargeInfo {
         /**
          * Auto-renewal for prepaid scenarios. true: auto-renew (default). false: do not auto-renew.
@@ -17893,32 +18223,12 @@ export declare namespace rdsmysql {
          * Instance ID bound to the current allowlist.
          */
         instanceId: string;
-        /**
-         * Instance name bound to the current allowlist.
-         */
-        instanceName: string;
-        /**
-         * Instance status.
-         */
-        instanceStatus: string;
-        /**
-         * Has the latest allowlist been synchronized? Values: true: Yes. false: No. Note: When modifying the allowlist, if the instance is not running, changes to the allowlist will not be immediately synchronized to the instance.
-         */
-        isLatest: boolean;
-        /**
-         * Private network ID of the instance.
-         */
-        vpc: string;
     }
     interface AllowListSecurityGroupBindInfo {
         /**
          * Mode for associating security groups. Values: IngressDirectionIp: Inbound IP. AssociateEcsIp: Associate ECS IP. Note: In the CreateAllowList API, the BindMode and SecurityGroupId fields of SecurityGroupBindInfoObject are required.
          */
         bindMode: string;
-        /**
-         * Security group IP address list.
-         */
-        ipLists: string[];
         /**
          * Security group ID.
          */
@@ -20273,6 +20583,16 @@ export declare namespace redis {
     }
 }
 export declare namespace rocketmq {
+    interface AccessKeyTopicPermission {
+        /**
+         * Permission type. AccessKey has permissions for this Topic. ALL: Publish and subscribe permissions. PUB: Publish permission. SUB: Subscribe permission. DENY: No publish or subscribe permissions
+         */
+        permission: string;
+        /**
+         * Topic name
+         */
+        topicName: string;
+    }
     interface AllowListAssociatedInstance {
         /**
          * Instance ID
@@ -20287,6 +20607,16 @@ export declare namespace rocketmq {
          */
         vpc: string;
     }
+    interface GetAccessKeyTopicPermission {
+        /**
+         * Permission type. AccessKey has permissions for this Topic. ALL: Publish and subscribe permissions. PUB: Publish permission. SUB: Subscribe permission. DENY: No publish or subscribe permissions
+         */
+        permission: string;
+        /**
+         * Topic name
+         */
+        topicName: string;
+    }
     interface GetAllowListAssociatedInstance {
         /**
          * Instance ID
@@ -20745,7 +21075,17 @@ export declare namespace storageebs {
          */
         value: string;
     }
-    interface GetSnapshotTag {
+    interface GetSnapshotPolicyTag {
+        /**
+         * Tag key
+         */
+        key: string;
+        /**
+         * Tag value
+         */
+        value: string;
+    }
+    interface GetSnapshotTag {
         /**
          * 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.
          */
@@ -20902,6 +21242,16 @@ export declare namespace storageebs {
          */
         value: string;
     }
+    interface SnapshotPolicyTag {
+        /**
+         * Tag key
+         */
+        key: string;
+        /**
+         * Tag value
+         */
+        value: 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.
@@ -21219,6 +21569,24 @@ export declare namespace tls {
          */
         severity: string;
     }
+    interface EtlTargetResource {
+        /**
+         * Name of the custom output target. You must use this name to refer to the output target in the data processing rules
+         */
+        alias: string;
+        /**
+         * Region of the log topic for storing processed logs
+         */
+        region: string;
+        /**
+         * Cross-account authorization role name
+         */
+        roleTrn: string;
+        /**
+         * Log topic ID for storing processed logs
+         */
+        topicId: string;
+    }
     interface GetAlarmAlarmNotifyGroup {
         /**
          * Alert notification group ID.
@@ -21683,471 +22051,1611 @@ export declare namespace tls {
          */
         severity: string;
     }
-    interface GetImportTaskImportSourceInfo {
+    interface GetEtlTargetResource {
         /**
-         * Kafka data source information. When sourceType is kafka, the KafkaSourceInfo field is required
+         * Name of the custom output target. You must use this name to refer to the output target in the data processing rules
          */
-        kafkaSourceInfo: outputs.tls.GetImportTaskImportSourceInfoKafkaSourceInfo;
+        alias: string;
         /**
-         * TOS data source information. When sourceType is tos, the TosSourceInfo field is required.
+         * Log project ID for storing processed logs
          */
-        tosSourceInfo: outputs.tls.GetImportTaskImportSourceInfoTosSourceInfo;
-    }
-    interface GetImportTaskImportSourceInfoKafkaSourceInfo {
+        projectId: string;
         /**
-         * Data encoding format. Available options: UTF-8, GBK.
+         * Log project name for storing processed logs
          */
-        encode: string;
+        projectName: string;
         /**
-         * Kafka consumer group. If not specified, the system will automatically create a Kafka consumer group.
+         * Region of the log topic for storing processed logs
          */
-        group: string;
+        region: 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 (,).
+         * Cross-account authorization role name
          */
-        host: string;
+        roleTrn: 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.
+         * Log topic ID for storing processed logs
          */
-        initialOffset: number;
+        topicId: string;
         /**
-         * If you are using Message Queue Kafka Edition, set this to the Kafka instance ID.
+         * Log topic name for storing processed logs
          */
-        instanceId: string;
+        topicName: string;
+    }
+    interface GetHostGroupRule {
         /**
-         * Whether to enable authentication. If you use a public service address, it is recommended to enable authentication.
+         * Container collection rules
          */
-        isNeedAuth: boolean;
+        containerRule: outputs.tls.GetHostGroupRuleContainerRule;
         /**
-         * Password authentication mechanism. Available options: PLAIN, SCRAM-SHA-256, and SCRAM-SHA-512.
+         * Time when the collection configuration was created.
          */
-        mechanism: string;
+        createTime: string;
         /**
-         * Kafka SASL user password for authentication.
+         * Extraction rule list.
          */
-        password: string;
+        excludePaths: outputs.tls.GetHostGroupRuleExcludePath[];
         /**
-         * Secure transmission protocol. Options include plaintext, sasl*ssl, ssl, and sasl*plaintext
+         * Extraction rules
          */
-        protocol: string;
+        extractRule: outputs.tls.GetHostGroupRuleExtractRule;
         /**
-         * Specify log time. Options: 0: Use Kafka message timestamp. 1: Use current system time.
+         * Collection type. 0: Host log file. 1: K8s container standard output. 2: Log file inside K8s container.
          */
-        timeSourceDefault: number;
+        inputType: number;
         /**
-         * Kafka Topic name. Separate multiple Kafka Topics with commas (,).
+         * Log sample.
          */
-        topic: string;
+        logSample: string;
         /**
-         * Kafka SASL username for authentication.
+         * Collection modes. minimalist*log: single-line full mode. json*log: JSON mode. delimiter*log: delimiter mode. multiline*log: multi-line full mode. fullregex_log: full regex mode.
          */
-        username: string;
-    }
-    interface GetImportTaskImportSourceInfoTosSourceInfo {
+        logType: string;
         /**
-         * TOS bucket name
+         * Time when the collection configuration was modified.
          */
-        bucket: string;
+        modifyTime: string;
         /**
-         * Compression mode for data in the TOS bucket. none: No compression. snappy: Compress using snappy. gzip: Compress using gzip. lz4: Compress using lz4.
+         * Data collection path list
          */
-        compressType: string;
+        paths: string[];
         /**
-         * Path of the file to be imported in the TOS bucket.
+         * Running status of the collection configuration. 0: Running. 1: Paused.
          */
-        prefix: string;
+        pause: number;
         /**
-         * Region where the TOS bucket is located. Cross-region data import is supported
+         * Collection configuration ID.
          */
-        region: string;
-    }
-    interface GetImportTaskTargetInfo {
+        ruleId: string;
         /**
-         * Log extraction rule.
+         * Name of the collection configuration.
          */
-        extractRule: outputs.tls.GetImportTaskTargetInfoExtractRule;
+        ruleName: string;
         /**
-         * 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.
+         * ID of the log topic to which the collection configuration belongs.
          */
-        logSample: string;
+        topicId: 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.
+         * Name of the log topic associated with the collection configuration
          */
-        logType: string;
+        topicName: string;
         /**
-         * Region.
+         * User-defined collection rules.
          */
-        region: string;
+        userDefineRule: outputs.tls.GetHostGroupRuleUserDefineRule;
     }
-    interface GetImportTaskTargetInfoExtractRule {
+    interface GetHostGroupRuleContainerRule {
         /**
-         * Basic content of log extraction rules.
-         */
-        extractRule: outputs.tls.GetImportTaskTargetInfoExtractRuleExtractRule;
-        /**
-         * Number of skipped rows. Only valid when the log type is delimiterLog and the import type is tos.
-         */
-        skipLineCount: number;
-        /**
-         * Time extraction regular expression, used to extract the time value from the TimeKey field and parse it as the collection time
-         */
-        timeExtractRegex: 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.
+         * Container name to collect. If no container name is specified, all containers in the machine group are collected. Supports regular expressions. For example, setting the container name to ^(container-test)$ collects all containers named container-test.
          */
-        timeZone: string;
-    }
-    interface GetImportTaskTargetInfoExtractRuleExtractRule {
+        containerNameRegex: string;
         /**
-         * 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
+         * Whether to add environment variables as log tags to the raw log data. When enabled, Log Service adds container environment variable fields to logs. Setting multiple key-value pairs adds multiple fields. For example, set Key to source and Value to data_source. If the container has the environment variable source=DC, Log Service adds the field **tag**data_source_*: DC to the log.
          */
-        beginRegex: string;
+        envTags: outputs.tls.GetHostGroupRuleContainerRuleEnvTag[];
         /**
-         * Delimiter. Only valid when LogType is delimiter_log.
+         * Container environment variable denylist/blocklist specifies containers to exclude from collection. If the denylist/blocklist is not enabled, all containers are collected. If enabled, Key is required and Value is optional. If Value is empty, all containers with the specified Key in their environment variables are excluded. If Value is not empty, only containers matching the key-value pair are excluded—that is, containers with the specified Key and a Value matching the given pattern. Value supports regex matching. For example, set Key to module and Value to ^(tcp|udp)$ to exclude containers with module:tcp or module:udp in their environment variables. Multiple key-value pairs use logical OR: any container matching any pair is excluded from collection. When the denylist/blocklist is enabled, Keys cannot be duplicated.
          */
-        delimiter: string;
+        excludeContainerEnvRegexes: outputs.tls.GetHostGroupRuleContainerRuleExcludeContainerEnvRegex[];
         /**
-         * Enable nanoseconds.
+         * The container Label denylist specifies which containers to exclude from collection. If not enabled, all containers are collected. If the container Label denylist is enabled, Key is required and Value is optional. If Value is empty, all containers with the specified Key in the container Label are excluded. If Value is not empty, only containers matching the Key-Value pair are excluded, meaning only containers with the specified Key and a Value matching the pattern are excluded. Value supports regex matching. For example, set Key to app and Value to ^(test1|test2)$ to exclude containers with app:test1 or app:test2 in the container Label. The logical relationship between multiple Key-Value pairs is OR, meaning any container Label matching any pair will be excluded from collection. When enabling the container Label denylist, Keys must not be duplicated.
          */
-        enableNanosecond: boolean;
+        excludeContainerLabelRegexes: outputs.tls.GetHostGroupRuleContainerRuleExcludeContainerLabelRegex[];
         /**
-         * Filter key regular expression.
+         * The container environment variable allowlist specifies which containers to collect by using environment variables as criteria. If the allowlist is not enabled, all containers are collected. When the container environment variable allowlist is enabled, you must enter key-value pairs. Key is required; Value is optional. If Value is empty: collect all containers that contain the Key in their environment variables. If Value is not empty: only collect containers where the Key exists and its value matches Value. Value supports regex matching. For example, set Key to module and Value to ^(tcp|udp)$ to collect only containers with module:tcp or module:udp in their environment variables. Multiple key-value pairs use logical OR; any container environment variable matching any key-value pair will be included in the collection scope. When the container environment variable allowlist is enabled, Keys must not be duplicated.
          */
-        filterKeyRegexes: outputs.tls.GetImportTaskTargetInfoExtractRuleExtractRuleFilterKeyRegex[];
+        includeContainerEnvRegexes: outputs.tls.GetHostGroupRuleContainerRuleIncludeContainerEnvRegex[];
         /**
-         * 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
+         * The container Label allowlist specifies which containers to collect based on container Labels. If the allowlist is not enabled, all containers are collected. When the container Label allowlist is enabled, you must enter key-value pairs. Key is required; Value is optional. If Value is empty, all containers with the specified Key in their container Label are collected. If Value is not empty, only containers with the specified Key and a Value matching the Value field are collected. Value supports regular expressions. For example, set Key to app and Value to ^(test1|test2)$ to collect only containers with app:test1 or app:test2 in their container Label. The logical relationship between multiple key-value pairs is OR; any container Label matching any key-value pair will be included in the collection scope. When the container Label allowlist is enabled, Keys must not be duplicated.
          */
-        keys: string[];
+        includeContainerLabelRegexes: outputs.tls.GetHostGroupRuleContainerRuleIncludeContainerLabelRegex[];
         /**
-         * Log regular expression
+         * Kubernetes container collection rules.
          */
-        logRegex: string;
+        kubernetesRule: outputs.tls.GetHostGroupRuleContainerRuleKubernetesRule;
         /**
-         * Log template.
+         * Collection information. stdout: Container standard output (stdout). stderr: Container standard error (stderr). all: Both container standard output (stdout) and standard error (stderr).
          */
-        logTemplate: outputs.tls.GetImportTaskTargetInfoExtractRuleExtractRuleLogTemplate;
+        stream: string;
+    }
+    interface GetHostGroupRuleContainerRuleEnvTag {
         /**
-         * 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.
+         * Key.
          */
-        quote: string;
+        key: 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.
+         * Value.
          */
-        timeFormat: string;
+        val: string;
+    }
+    interface GetHostGroupRuleContainerRuleExcludeContainerEnvRegex {
         /**
-         * 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
+         * Key.
          */
-        timeKey: string;
+        key: string;
         /**
-         * Time sample. Used to verify whether the entered time parsing format is correct
+         * Value.
          */
-        timeSample: string;
+        val: string;
+    }
+    interface GetHostGroupRuleContainerRuleExcludeContainerLabelRegex {
         /**
-         * When uploading logs that failed to parse, specify the key name for the failed logs. UnMatchUpLoadSwitch=true and UnMatchLogKey must be used together.
+         * Key.
          */
-        unMatchLogKey: string;
+        key: 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.
+         * Value.
          */
-        unMatchUpLoadSwitch: boolean;
+        val: string;
     }
-    interface GetImportTaskTargetInfoExtractRuleExtractRuleFilterKeyRegex {
+    interface GetHostGroupRuleContainerRuleIncludeContainerEnvRegex {
         /**
          * Key.
          */
         key: string;
         /**
-         * Regular expression.
+         * Value.
          */
-        regex: string;
+        val: string;
     }
-    interface GetImportTaskTargetInfoExtractRuleExtractRuleLogTemplate {
+    interface GetHostGroupRuleContainerRuleIncludeContainerLabelRegex {
         /**
-         * Format.
+         * Key.
          */
-        format: string;
+        key: string;
         /**
-         * Type
+         * Value.
          */
-        type: string;
+        val: string;
     }
-    interface GetImportTaskTaskStatistics {
+    interface GetHostGroupRuleContainerRuleKubernetesRule {
         /**
-         * Total resource bytes enumerated
+         * Whether to add Kubernetes Annotations as log tags to the raw log data. When enabled, the log service adds Kubernetes Pod Annotation fields to the logs. Setting multiple key-value pairs adds multiple fields. For example, set Key to sink and Value to data_sink. If the Pod contains the Annotation sink=ck, the log will include the field **tag**data_sink_*: ck.
          */
-        bytesTotal: number;
+        annotationTags: outputs.tls.GetHostGroupRuleContainerRuleKubernetesRuleAnnotationTag[];
         /**
-         * Bytes transferred.
+         * Whether to add all Kubernetes Labels as log tags to the raw log data. When enabled, the log service adds fields for all Labels in the Kubernetes Pod to the log. For example, if the Pod has Label source=DC and destination=CS, the log will include fields **tag**source__: DC and **tag**destination__: CS.
          */
-        bytesTransferred: number;
+        enableAllLabelTag: boolean;
         /**
-         * Number of resources failed to import.
+         * Pod Annotation denylist is used to specify containers that are not collected. If you need to set a Pod Annotation denylist, Key is required and Value is optional. If Value is empty, all containers under Pods whose Pod Annotation contains the Key will be excluded. If Value is not empty, only containers under Pods whose Pod Annotation contains the Key and whose value matches the Value will be excluded. By default, Value uses string matching, meaning only when Value and the Pod Annotation value are exactly the same will it match. If the value starts with ^ and ends with $, it is treated as a regular expression match. For example, set Key to app and Value to ^(test1|test2)$ to match containers under Pods whose Pod Annotation contains app:test1 or app:test2. Note: The logical relationship between multiple Key-Value pairs is OR, meaning as long as the Pod Annotation matches any pair, it will be included in the collection scope. When enabling the Pod Annotation denylist, Keys must not be duplicated. For fuzzy regular expression matching, you must add .*. For example, ^(http.*)$ matches strings that start with http
          */
-        failed: number;
+        excludePodAnnotationRegexes: outputs.tls.GetHostGroupRuleContainerRuleKubernetesRuleExcludePodAnnotationRegex[];
         /**
-         * Number of resources not found.
+         * Specify containers to exclude from collection using the Pod Label denylist. If not enabled, all containers are collected. To set a Pod Label denylist, Key is required and Value is optional. If Value is empty, all containers with the specified Key in the Pod Label are excluded from collection. If Value is not empty, only containers with the specified Key and a Value matching the pattern are excluded. Value supports regex matching. For example, set Key to module and Value to ^(tcp|udp)$ to exclude containers with module:tcp or module:udp in the Pod Label. Note: The logical relationship between multiple Key-Value pairs is OR, meaning any Pod Label matching any pair will be excluded from collection. When enabling the Pod Label denylist, Keys must not be duplicated. For fuzzy regex matching, you must add .*. For example, ^(http.*)$ matches any string starting with http.
          */
-        notExist: number;
+        excludePodLabelRegexes: outputs.tls.GetHostGroupRuleContainerRuleKubernetesRuleExcludePodLabelRegex[];
         /**
-         * Number of resources skipped during import
+         * Pod Annotation Allowlist specifies which containers to collect. If you need to set a Pod Annotation Allowlist, Key is required and Value is optional. If Value is empty, all containers in Pods with the specified Key in their Pod Annotation are matched. If Value is not empty, only containers in Pods where the Pod Annotation contains the Key and its value matches Value are matched. By default, Value uses string matching, meaning only exact matches between Value and the Pod Annotation value are considered. If Value starts with ^ and ends with $, it uses regex matching. For example, set Key to app and Value to ^(test1|test2)$ to match containers in Pods with Pod Annotation app:test1 or app:test2. Note: Multiple Key-Value pairs use logical OR, so any Pod Annotation matching any pair will be included in the collection scope. When enabling the Pod Annotation Allowlist, Keys must not be duplicated. For regex fuzzy matching, you must add .*. For example, ^(http.*)$ matches values starting with http
          */
-        skipped: number;
+        includePodAnnotationRegexes: outputs.tls.GetHostGroupRuleContainerRuleKubernetesRuleIncludePodAnnotationRegex[];
         /**
-         * Task status. Status of the import task. Preparing: Preparing for import. Importing: Importing data. Success: Import completed successfully. Failed: Import failed. Stopped: Import paused.
+         * Pod label allowlist specifies which containers to collect. If the Pod label allowlist is not enabled, all containers are collected. To set a Pod label allowlist, Key is required. If Value is empty, all containers with the Key in their Pod label are collected. If Value is not empty, only containers with the Key in their Pod label and a Value matching the specified pattern are collected. Value supports regex matching. For example, set Key to module and Value to ^(tcp|udp)$ to collect only containers with module:tcp or module:udp in their Pod label. Note: The logical relationship between multiple key-value pairs is OR, meaning any matching pair will include the Pod in the collection scope. When the Pod label allowlist is enabled, Keys must be unique. For fuzzy regex matching, you must add .*. For example, ^(http.*)$ matches strings starting with http.
          */
-        taskStatus: string;
+        includePodLabelRegexes: outputs.tls.GetHostGroupRuleContainerRuleKubernetesRuleIncludePodLabelRegex[];
         /**
-         * Total number of resources enumerated.
+         * Choose whether to add Kubernetes labels as log tags to the original log data. When enabled, the log service adds Kubernetes Pod label fields to the logs. Setting multiple key-value pairs adds multiple fields. For example, set Key to source and Value to data_source. If the Pod contains the label source=DC, the log will include the field **tag**data_source_*: DC.
          */
-        total: number;
+        labelTags: outputs.tls.GetHostGroupRuleContainerRuleKubernetesRuleLabelTag[];
         /**
-         * Number of records transferred.
+         * Name of the Kubernetes Namespace to be collected. If not specified, all containers are collected. Namespace names support regular expression matching. For example, setting the Namespace name to ^(tcp|udp)$ collects all containers under the tcp and udp namespaces.
          */
-        transferred: number;
-    }
-    interface GetIndexFullText {
+        namespaceNameRegex: string;
         /**
-         * Case sensitivity. true: Case sensitive. false: Not case sensitive.
+         * Pod name is used to specify the Pod(s) to be collected. If the Pod name is not specified, all containers are collected. Pod name supports regex matching. For example, setting the Pod name to ^(http.*)$ collects all containers under Pods whose names start with http.
          */
-        caseSensitive: boolean;
+        podNameRegex: string;
         /**
-         * 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.
+         * 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.
          */
-        delimiter: string;
+        workloadNameRegex: 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.
+         * Specify containers to collect by workload type. Only one type can be selected. If no type is specified, containers of all types will be collected. Supported workload types are: Deployment: stateless workload StatefulSet: stateful workload DaemonSet: daemon process Job: job CronJob: scheduled job
          */
-        includeChinese: boolean;
+        workloadType: string;
     }
-    interface GetIndexKeyValue {
+    interface GetHostGroupRuleContainerRuleKubernetesRuleAnnotationTag {
         /**
-         * 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: string;
         /**
-         * Field description information required for configuring key-value indexes.
+         * Value.
          */
-        value: outputs.tls.GetIndexKeyValueValue;
+        val: string;
     }
-    interface GetIndexKeyValueValue {
-        /**
-         * Indicates whether the index was added automatically. true: The index was added automatically. false: The index was not added automatically.
-         */
-        autoIndexFlag: boolean;
+    interface GetHostGroupRuleContainerRuleKubernetesRuleExcludePodAnnotationRegex {
         /**
-         * Whether to distinguish case. Default is false.
+         * Key.
          */
-        caseSensitive: boolean;
+        key: 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.
+         * Value.
          */
-        delimiter: string;
+        val: string;
+    }
+    interface GetHostGroupRuleContainerRuleKubernetesRuleExcludePodLabelRegex {
         /**
-         * 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.
+         * Key.
          */
-        includeChinese: boolean;
+        key: string;
         /**
-         * Create indexes for all fields with text values in the JSON field.
+         * Value.
          */
-        indexAll: boolean;
+        val: string;
+    }
+    interface GetHostGroupRuleContainerRuleKubernetesRuleIncludePodAnnotationRegex {
         /**
-         * Enable automatic indexing and statistics for JSON fields. true: Enable automatic indexing and statistics. false: Disable automatic indexing and statistics.
+         * Key.
          */
-        indexSqlAll: boolean;
+        key: string;
         /**
-         * When ValueType is json, you can configure key-value indexes for JSON subfields using the JsonKeys field, which is an array of KeyValueInfo. Each element in the JsonKeys list is a KeyValueInfo, and you can further nest text, long, and double type subfields. For subfields in JSON key-value indexes, use . to indicate the hierarchy between JSON fields. For example, the JSON field namelist contains a text-type subfield totalcount and a JSON-type info, which itself contains the field name. Each field name should be configured as totalcount and info.name, respectively. The SqlFlag setting for subfield key-value indexes defined in JsonKeys must match their parent field, meaning they must be enabled or disabled together. The default is disabled. Subfields do not support separate settings for Delimiter, CaseSensitive, or IncludeChinese. For text-type fields, CaseSensitive, Delimiter, and IncludeChinese always inherit the parent field settings. This is only set when ValueType is json.
+         * Value.
          */
-        jsonKeys: outputs.tls.GetIndexKeyValueValueJsonKey[];
+        val: string;
+    }
+    interface GetHostGroupRuleContainerRuleKubernetesRuleIncludePodLabelRegex {
         /**
-         * 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.
+         * Key.
          */
-        sqlFlag: boolean;
+        key: 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.
+         * Value.
          */
-        valueType: string;
+        val: string;
     }
-    interface GetIndexKeyValueValueJsonKey {
+    interface GetHostGroupRuleContainerRuleKubernetesRuleLabelTag {
         /**
-         * 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: string;
         /**
-         * Field description information required for configuring key-value indexes.
+         * Value.
          */
-        value: outputs.tls.GetIndexKeyValueValueJsonKeyValue;
+        val: string;
     }
-    interface GetIndexKeyValueValueJsonKeyValue {
+    interface GetHostGroupRuleExcludePath {
+        /**
+         * Collection path type. File: file name. Path: directory.
+         */
+        type: 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: string;
+    }
+    interface GetHostGroupRuleExtractRule {
+        /**
+         * The regex pattern required to match the first line of the log. This is valid only when LogType is multiline*log or fullregex*log. The pattern must be a valid regular expression.
+         */
+        beginRegex: string;
+        /**
+         * Log delimiter. Valid only when LogType is delimiter_log.
+         */
+        delimiter: string;
+        /**
+         * Enable nanosecond precision time. When enabled, log time parsing will report time with nanosecond precision. true: Enable nanosecond precision time. false: Disable nanosecond precision time.
+         */
+        enableNanosecond: boolean;
+        /**
+         * Filter rule list.
+         */
+        filterKeyRegexes: outputs.tls.GetHostGroupRuleExtractRuleFilterKeyRegex[];
+        /**
+         * List of log field names (Keys).
+         */
+        keys: string[];
+        /**
+         * The entire log entry must match the regular expression. This is only valid when the log type is fullregex_log. The regular expression must be valid.
+         */
+        logRegex: string;
+        /**
+         * Automatically extract log fields based on the specified log template.
+         */
+        logTemplate: outputs.tls.GetHostGroupRuleExtractRuleLogTemplate;
+        /**
+         * Quotation mark. Content enclosed by quotation marks is parsed as a complete field and not separated. Only valid when LogType is delimiter_log.
+         */
+        quote: string;
+        /**
+         * Regular expression for extracting time, used to extract the time value from the TimeKey field and parse it as the collection time.
+         */
+        timeExtractRegex: string;
+        /**
+         * Parsing format for the time field. If a specified time field in the log is used as the log timestamp, you must provide TimeKey and TimeFormat.
+         */
+        timeFormat: string;
+        /**
+         * Field name for the log time field. If a specified time field in the log is used as the log timestamp, you must provide TimeKey and TimeFormat.
+         */
+        timeKey: string;
+        /**
+         * Sample time. Used to verify whether the specified time parsing format is correct.
+         */
+        timeSample: string;
+        /**
+         * Time zone. Supports machine time zone (default) and custom time zone. Custom time zone supports GMT and UTC.
+         */
+        timeZone: string;
+        /**
+         * Key name for logs that failed to parse when uploading
+         */
+        unMatchLogKey: string;
+        /**
+         * Upload logs that failed to parse. UnMatchUpLoadSwitch=true and UnMatchLogKey must be used together. true: Upload logs that failed to parse. false: Do not upload logs that failed to parse.
+         */
+        unMatchUpLoadSwitch: boolean;
+    }
+    interface GetHostGroupRuleExtractRuleFilterKeyRegex {
+        /**
+         * Name of the filter field.
+         */
+        key: string;
+        /**
+         * The log content of the filter field must match the specified regular expression.
+         */
+        regex: string;
+    }
+    interface GetHostGroupRuleExtractRuleLogTemplate {
+        /**
+         * Log template format
+         */
+        format: string;
+        /**
+         * Log template type. Supported types: Nginx (Nginx log template type).
+         */
+        type: string;
+    }
+    interface GetHostGroupRuleUserDefineRule {
+        /**
+         * Advanced parameters are used for extended configuration. After enabling extended configuration, you can customize advanced behaviors of LogCollector, such as when to release file handles. Note: If multiple conditions for releasing handles are specified, the handle will be released and log file monitoring will end as soon as any condition is met.
+         */
+        advanced: outputs.tls.GetHostGroupRuleUserDefineRuleAdvanced;
+        /**
+         * Whether to upload the Label information of the host group to the log service. Disabled by default. true: LogCollector uploads the Label information of the host group to the specified field. You can specify the field name in the HostGroupLabelKey parameter. false (default): LogCollector does not upload the Label information of the host group.
+         */
+        enableHostGroupLabel: boolean;
+        /**
+         * Whether to upload the hostname field. Default is disabled. true: Adds a field to the original log to record the log source's hostname. Specify the hostname field name using HostnameKey. false (default): Does not add the hostname field.
+         */
+        enableHostname: boolean;
+        /**
+         * Whether to upload raw logs. true: Upload raw logs. false (default): Do not upload raw logs.
+         */
+        enableRawLog: boolean;
+        /**
+         * Add constant fields to logs. Constant fields must follow these restrictions: Up to 5 constant fields can be uploaded. Field name (Key) must be unique and not empty. Length: 1–128 characters, including letters, numbers, and special characters (-*./), and cannot start with an underscore. Field value (Value) must not be empty, maximum length is 512 KiB.
+         */
+        fields: outputs.tls.GetHostGroupRuleUserDefineRuleField[];
+        /**
+         * Field name used to store machine group label information.
+         */
+        hostGroupLabelKey: string;
+        /**
+         * hostname field name. Only required when EnableHostname is set to true.
+         */
+        hostnameKey: string;
+        /**
+         * Ignore log files that have not been updated for a specified duration, in hours.
+         */
+        ignoreOlder: number;
+        /**
+         * Allows multiple log file collections. Empty: Uses the log file ID (including file inode, device, and checksum of the first N bytes) to uniquely identify the log file. RuleID: Uses the collection rule ID and log file ID to uniquely identify the log file. TopicIDRuleName: Uses the log topic ID, collection rule Name, and log file ID to uniquely identify the log file.
+         */
+        multiCollectsType: string;
+        /**
+         * Rules for parsing the collection path. After setting the rule, fields in the collection path are extracted using the specified regex and added as metadata to the log data. Note: This parameter is not supported when collecting container standard output.
+         */
+        parsePathRule: outputs.tls.GetHostGroupRuleUserDefineRuleParsePathRule;
+        /**
+         * LogCollector plugin configuration. After enabling plugin configuration, you can add one or more LogCollector processor plugins to parse logs with complex or variable structures.
+         */
+        plugin: outputs.tls.GetHostGroupRuleUserDefineRulePlugin;
+        /**
+         * Original log field name. Only effective when EnableRawLog is set to true. RawLogKey defaults to **raw**, meaning the original log data will be encapsulated in the **raw** field and uploaded to the log service together with the parsed log data
+         */
+        rawLogKey: string;
+        /**
+         * Rules for routing log partitions. If this parameter is not set, logs are written using the default load balancing mode, and packets are written to any available Shard. If set, logs are collected using the HashKey routing Shard mode, and the log service writes data to the Shard containing the specified Key value.
+         */
+        shardHashKey: outputs.tls.GetHostGroupRuleUserDefineRuleShardHashKey;
+        /**
+         * LogCollector collection strategy, specifying whether LogCollector collects incremental logs or full logs. The default is false, which means full log collection. true: incremental collection. When LogCollector collects logs, it only collects newly added content in the file. When a monitored log file receives new log entries, LogCollector is triggered to collect logs. For log files being collected for the first time, LogCollector automatically determines the collection position based on the incremental threshold TailSizeKb you specify. If the new file size does not exceed the incremental threshold, collection starts from the beginning of the new file. If the new file size exceeds the incremental threshold, collection starts from the position at the end of the file minus the incremental threshold, meaning only incremental logs are collected. For log files that are not being collected for the first time, LogCollector determines the collection position based on the Checkpoint and continues collecting. false: (default) full collection. LogCollector collects logs from the beginning of each file, including historical log data.
+         */
+        tailFiles: boolean;
+        /**
+         * Incremental collection backtracking threshold, in KiB. When LogCollector uses incremental collection, for the first collection of a log file: if the new log file size does not exceed the TailSizeKb value, collection starts from the beginning of the file. If the new log file size exceeds the TailSizeKb value, collection starts from the position TailSizeKb from the end of the file.
+         */
+        tailSizeKb: number;
+    }
+    interface GetHostGroupRuleUserDefineRuleAdvanced {
+        /**
+         * After reading to the end of the log file, whether to release the file handle. Default is false.
+         */
+        closeEof: boolean;
+        /**
+         * Wait time before releasing log file handles. If no new logs are written to a log file for the specified duration, the handle for that log file is released. Unit: seconds. Range: 1–300 seconds. Default: 60 seconds.
+         */
+        closeInactive: number;
+        /**
+         * Whether to release the handle of the log file after it is removed. Default is false.
+         */
+        closeRemoved: boolean;
+        /**
+         * Whether to release the handle of the log file after it is renamed. Default is false.
+         */
+        closeRenamed: boolean;
+        /**
+         * Maximum duration for LogCollector to monitor log files, in seconds. The default is 0 seconds, meaning LogCollector does not limit the monitoring duration. Timing starts when LogCollector begins monitoring the log file. After the specified duration is exceeded, regardless of whether the log file has been fully read, LogCollector immediately releases the file handle and stops monitoring.
+         */
+        closeTimeout: number;
+        /**
+         * Maximum wait time when LogCollector does not read a line break. Unit: seconds. Default: 5s. LogCollector starts timing when it begins reading log file content. If no line break is read within the specified time, it will send the buffered logs. If the file write interval is large, a complete log entry may be split into two parts and written separately. Adjust this parameter based on your log write interval.
+         */
+        noLineTerminatorEofMaxTime: number;
+    }
+    interface GetHostGroupRuleUserDefineRuleField {
+        /**
+         * Key.
+         */
+        key: string;
+        /**
+         * Value.
+         */
+        val: string;
+    }
+    interface GetHostGroupRuleUserDefineRuleParsePathRule {
+        /**
+         * List of field names. Log Service parses PathSample into multiple fields using regular expressions (Regex). Keys specify the name of each field. You can configure up to 100 field names. Field names cannot be empty or duplicated.
+         */
+        keys: string[];
+        /**
+         * Sample collection path for actual scenarios. The sample path must be an absolute path. Wildcards *, ?, ** are not allowed in the sample path.
+         */
+        pathSample: string;
+        /**
+         * Regular expression used to extract the path field. It must match the example collection path; otherwise, extraction will fail.
+         */
+        regex: string;
+    }
+    interface GetHostGroupRuleUserDefineRulePlugin {
+        /**
+         * LogCollector plugins. For supported plugin lists and parameter descriptions, see LogCollector plugin overview.
+         */
+        processors: string;
+    }
+    interface GetHostGroupRuleUserDefineRuleShardHashKey {
+        /**
+         * The HashKey of the log group specifies the shard where the current log group will be written. The valid range for this parameter is [00000000000000000000000000000000-ffffffffffffffffffffffffffffffff).
+         */
+        hashKey: string;
+    }
+    interface GetImportTaskImportSourceInfo {
+        /**
+         * Kafka data source information. When sourceType is kafka, the KafkaSourceInfo field is required
+         */
+        kafkaSourceInfo: outputs.tls.GetImportTaskImportSourceInfoKafkaSourceInfo;
+        /**
+         * TOS data source information. When sourceType is tos, the TosSourceInfo field is required.
+         */
+        tosSourceInfo: outputs.tls.GetImportTaskImportSourceInfoTosSourceInfo;
+    }
+    interface GetImportTaskImportSourceInfoKafkaSourceInfo {
+        /**
+         * Data encoding format. Available options: UTF-8, GBK.
+         */
+        encode: string;
+        /**
+         * Kafka consumer group. If not specified, the system will automatically create a Kafka consumer group.
+         */
+        group: 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: 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: number;
+        /**
+         * If you are using Message Queue Kafka Edition, set this to the Kafka instance ID.
+         */
+        instanceId: string;
+        /**
+         * Whether to enable authentication. If you use a public service address, it is recommended to enable authentication.
+         */
+        isNeedAuth: boolean;
+        /**
+         * Password authentication mechanism. Available options: PLAIN, SCRAM-SHA-256, and SCRAM-SHA-512.
+         */
+        mechanism: string;
+        /**
+         * Kafka SASL user password for authentication.
+         */
+        password: string;
+        /**
+         * Secure transmission protocol. Options include plaintext, sasl*ssl, ssl, and sasl*plaintext
+         */
+        protocol: string;
+        /**
+         * Specify log time. Options: 0: Use Kafka message timestamp. 1: Use current system time.
+         */
+        timeSourceDefault: number;
+        /**
+         * Kafka Topic name. Separate multiple Kafka Topics with commas (,).
+         */
+        topic: string;
+        /**
+         * Kafka SASL username for authentication.
+         */
+        username: string;
+    }
+    interface GetImportTaskImportSourceInfoTosSourceInfo {
+        /**
+         * TOS bucket name
+         */
+        bucket: 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: string;
+        /**
+         * Path of the file to be imported in the TOS bucket.
+         */
+        prefix: string;
+        /**
+         * Region where the TOS bucket is located. Cross-region data import is supported
+         */
+        region: string;
+    }
+    interface GetImportTaskTargetInfo {
+        /**
+         * Log extraction rule.
+         */
+        extractRule: outputs.tls.GetImportTaskTargetInfoExtractRule;
+        /**
+         * 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: 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: string;
+        /**
+         * Region.
+         */
+        region: string;
+    }
+    interface GetImportTaskTargetInfoExtractRule {
+        /**
+         * Basic content of log extraction rules.
+         */
+        extractRule: outputs.tls.GetImportTaskTargetInfoExtractRuleExtractRule;
+        /**
+         * Number of skipped rows. Only valid when the log type is delimiterLog and the import type is tos.
+         */
+        skipLineCount: number;
+        /**
+         * Time extraction regular expression, used to extract the time value from the TimeKey field and parse it as the collection time
+         */
+        timeExtractRegex: 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: string;
+    }
+    interface GetImportTaskTargetInfoExtractRuleExtractRule {
+        /**
+         * 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: string;
+        /**
+         * Delimiter. Only valid when LogType is delimiter_log.
+         */
+        delimiter: string;
+        /**
+         * Enable nanoseconds.
+         */
+        enableNanosecond: boolean;
+        /**
+         * Filter key regular expression.
+         */
+        filterKeyRegexes: outputs.tls.GetImportTaskTargetInfoExtractRuleExtractRuleFilterKeyRegex[];
+        /**
+         * 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: string[];
+        /**
+         * Log regular expression
+         */
+        logRegex: string;
+        /**
+         * Log template.
+         */
+        logTemplate: outputs.tls.GetImportTaskTargetInfoExtractRuleExtractRuleLogTemplate;
+        /**
+         * 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: 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: 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: string;
+        /**
+         * Time sample. Used to verify whether the entered time parsing format is correct
+         */
+        timeSample: 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: 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: boolean;
+    }
+    interface GetImportTaskTargetInfoExtractRuleExtractRuleFilterKeyRegex {
+        /**
+         * Key.
+         */
+        key: string;
+        /**
+         * Regular expression.
+         */
+        regex: string;
+    }
+    interface GetImportTaskTargetInfoExtractRuleExtractRuleLogTemplate {
+        /**
+         * Format.
+         */
+        format: string;
+        /**
+         * Type
+         */
+        type: string;
+    }
+    interface GetImportTaskTaskStatistics {
+        /**
+         * Total resource bytes enumerated
+         */
+        bytesTotal: number;
+        /**
+         * Bytes transferred.
+         */
+        bytesTransferred: number;
+        /**
+         * Number of resources failed to import.
+         */
+        failed: number;
+        /**
+         * Number of resources not found.
+         */
+        notExist: number;
+        /**
+         * Number of resources skipped during import
+         */
+        skipped: 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: string;
+        /**
+         * Total number of resources enumerated.
+         */
+        total: number;
+        /**
+         * Number of records transferred.
+         */
+        transferred: number;
+    }
+    interface GetIndexFullText {
+        /**
+         * Case sensitivity. true: Case sensitive. false: Not case sensitive.
+         */
+        caseSensitive: 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: 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: boolean;
+    }
+    interface GetIndexKeyValue {
+        /**
+         * 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: string;
+        /**
+         * Field description information required for configuring key-value indexes.
+         */
+        value: outputs.tls.GetIndexKeyValueValue;
+    }
+    interface GetIndexKeyValueValue {
+        /**
+         * Indicates whether the index was added automatically. true: The index was added automatically. false: The index was not added automatically.
+         */
+        autoIndexFlag: boolean;
+        /**
+         * Whether to distinguish case. Default is false.
+         */
+        caseSensitive: 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: 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: boolean;
+        /**
+         * Create indexes for all fields with text values in the JSON field.
+         */
+        indexAll: boolean;
+        /**
+         * Enable automatic indexing and statistics for JSON fields. true: Enable automatic indexing and statistics. false: Disable automatic indexing and statistics.
+         */
+        indexSqlAll: boolean;
+        /**
+         * When ValueType is json, you can configure key-value indexes for JSON subfields using the JsonKeys field, which is an array of KeyValueInfo. Each element in the JsonKeys list is a KeyValueInfo, and you can further nest text, long, and double type subfields. For subfields in JSON key-value indexes, use . to indicate the hierarchy between JSON fields. For example, the JSON field namelist contains a text-type subfield totalcount and a JSON-type info, which itself contains the field name. Each field name should be configured as totalcount and info.name, respectively. The SqlFlag setting for subfield key-value indexes defined in JsonKeys must match their parent field, meaning they must be enabled or disabled together. The default is disabled. Subfields do not support separate settings for Delimiter, CaseSensitive, or IncludeChinese. For text-type fields, CaseSensitive, Delimiter, and IncludeChinese always inherit the parent field settings. This is only set when ValueType is json.
+         */
+        jsonKeys: outputs.tls.GetIndexKeyValueValueJsonKey[];
+        /**
+         * 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: 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: string;
+    }
+    interface GetIndexKeyValueValueJsonKey {
+        /**
+         * 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: string;
+        /**
+         * Field description information required for configuring key-value indexes.
+         */
+        value: outputs.tls.GetIndexKeyValueValueJsonKeyValue;
+    }
+    interface GetIndexKeyValueValueJsonKeyValue {
         /**
          * Indicates whether the index was added automatically. true: The index was added automatically. false: The index was not added automatically.
          */
-        autoIndexFlag: boolean;
+        autoIndexFlag: boolean;
+        /**
+         * Whether to distinguish case. Default is false.
+         */
+        caseSensitive: 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: 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: boolean;
+        /**
+         * Create indexes for all fields with text values in the JSON field.
+         */
+        indexAll: boolean;
+        /**
+         * Enable automatic indexing and statistics for JSON fields. true: Enable automatic indexing and statistics. false: Disable automatic indexing and statistics.
+         */
+        indexSqlAll: 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: 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: string;
+    }
+    interface GetIndexUserInnerKeyValue {
+        /**
+         * 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: string;
+        /**
+         * Field description information required for configuring key-value indexes.
+         */
+        value: outputs.tls.GetIndexUserInnerKeyValueValue;
+    }
+    interface GetIndexUserInnerKeyValueValue {
+        /**
+         * Indicates whether the index was added automatically. true: The index was added automatically. false: The index was not added automatically.
+         */
+        autoIndexFlag: boolean;
+        /**
+         * Whether to distinguish case. Default is false.
+         */
+        caseSensitive: 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: 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: boolean;
+        /**
+         * Create indexes for all fields with text values in the JSON field.
+         */
+        indexAll: boolean;
+        /**
+         * Enable automatic indexing and statistics for JSON fields. true: Enable automatic indexing and statistics. false: Disable automatic indexing and statistics.
+         */
+        indexSqlAll: boolean;
+        /**
+         * When ValueType is json, you can configure key-value indexes for JSON subfields using the JsonKeys field, which is an array of KeyValueInfo. Each element in the JsonKeys list is a KeyValueInfo, and you can further nest text, long, and double type subfields. For subfields in JSON key-value indexes, use . to indicate the hierarchy between JSON fields. For example, the JSON field namelist contains a text-type subfield totalcount and a JSON-type info, which itself contains the field name. Each field name should be configured as totalcount and info.name, respectively. The SqlFlag setting for subfield key-value indexes defined in JsonKeys must match their parent field, meaning they must be enabled or disabled together. The default is disabled. Subfields do not support separate settings for Delimiter, CaseSensitive, or IncludeChinese. For text-type fields, CaseSensitive, Delimiter, and IncludeChinese always inherit the parent field settings. This is only set when ValueType is json.
+         */
+        jsonKeys: outputs.tls.GetIndexUserInnerKeyValueValueJsonKey[];
+        /**
+         * 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: 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: string;
+    }
+    interface GetIndexUserInnerKeyValueValueJsonKey {
+        /**
+         * 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: string;
+        /**
+         * Field description information required for configuring key-value indexes.
+         */
+        value: outputs.tls.GetIndexUserInnerKeyValueValueJsonKeyValue;
+    }
+    interface GetIndexUserInnerKeyValueValueJsonKeyValue {
+        /**
+         * Indicates whether the index was added automatically. true: The index was added automatically. false: The index was not added automatically.
+         */
+        autoIndexFlag: boolean;
+        /**
+         * Whether to distinguish case. Default is false.
+         */
+        caseSensitive: 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: 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: boolean;
+        /**
+         * Create indexes for all fields with text values in the JSON field.
+         */
+        indexAll: boolean;
+        /**
+         * Enable automatic indexing and statistics for JSON fields. true: Enable automatic indexing and statistics. false: Disable automatic indexing and statistics.
+         */
+        indexSqlAll: 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: 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: string;
+    }
+    interface GetProjectTag {
+        /**
+         * Tag key
+         */
+        key: string;
+        /**
+         * Tag value
+         */
+        value: string;
+    }
+    interface GetRuleContainerRule {
+        /**
+         * 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: string;
+        /**
+         * Whether to add environment variables as log tags to the raw log data. When enabled, the log service adds container environment variable fields to the logs. Setting multiple key-value pairs adds multiple fields. For example, set Key to source and Value to data_source. If the container has the environment variable source=DC, the log will include the field **tag**data_source_*: DC
+         */
+        envTags: outputs.tls.GetRuleContainerRuleEnvTag[];
+        /**
+         * The container environment variable denylist specifies which containers are excluded from collection. If the denylist is not enabled, all containers are collected. When the container environment variable denylist is enabled, Key is required and Value is optional. If Value is empty, all containers whose environment variables contain the Key are excluded from collection. If Value is not empty, only containers with a matching key-value pair are excluded, meaning only containers whose environment variables contain the Key and whose value matches the Value are excluded. Value supports regular expressions. For example, if Key is set to module and Value is set to ^(tcp|udp)$, containers with environment variables module:tcp or module:udp are excluded from collection. Multiple key-value pairs are evaluated with a logical OR, so any container environment variable matching any key-value pair will be excluded from collection. When the container environment variable denylist is enabled, Keys must be unique.
+         */
+        excludeContainerEnvRegexes: outputs.tls.GetRuleContainerRuleExcludeContainerEnvRegex[];
+        /**
+         * Container label denylist specifies containers to exclude from collection. If the denylist is not enabled, all containers will be collected. If the container label denylist is enabled, Key is required and Value is optional. If Value is empty, all containers with the Key in their label will be excluded. If Value is not empty, only containers matching the key-value pair will be excluded—that is, containers with the Key in their label and a Value matching the specified pattern. Value supports regex matching; for example, set Key to app and Value to ^(test1|test2)$ to exclude containers with labels app:test1 and app:test2. Multiple key-value pairs use logical OR; any container label matching any pair will be excluded from collection. When the container label denylist is enabled, Keys must not be duplicated.
+         */
+        excludeContainerLabelRegexes: outputs.tls.GetRuleContainerRuleExcludeContainerLabelRegex[];
+        /**
+         * The container environment variable allowlist specifies which containers to collect using container environment variables. If the allowlist is not enabled, all containers are collected. When the container environment variable allowlist is enabled, you must enter key-value pairs. Key is required; Value is optional. If Value is empty, all containers containing the Key in their environment variables are collected. If Value is not empty, only containers with the Key in their environment variables and a Value matching the specified value are collected. Value supports regular expression matching. For example, if Key is set to module and Value is set to ^(tcp|udp)$, only containers with module:tcp or module:udp in their environment variables are collected. The logical relationship between multiple key-value pairs is OR, meaning any container environment variable matching any key-value pair will be included in the collection scope. When the container environment variable allowlist is enabled, Keys must not be duplicated.
+         */
+        includeContainerEnvRegexes: outputs.tls.GetRuleContainerRuleIncludeContainerEnvRegex[];
+        /**
+         * The container label allowlist specifies which containers to collect based on container labels. If the allowlist is not enabled, all containers are collected. When the container label allowlist is enabled, you must specify key-value pairs. Key is required and Value is optional. If Value is empty, all containers whose labels contain the Key are collected. If Value is not empty, only containers whose labels contain the Key and whose value matches the Value are collected. Value supports regular expressions. For example, if Key is set to app and Value is set to ^(test1|test2)$, only containers with labels app:test1 or app:test2 are collected. Multiple key-value pairs are evaluated with a logical OR, so any container label matching any key-value pair will be included in the collection scope. When the container label allowlist is enabled, Keys must be unique.
+         */
+        includeContainerLabelRegexes: outputs.tls.GetRuleContainerRuleIncludeContainerLabelRegex[];
+        /**
+         * Kubernetes container collection rules.
+         */
+        kubernetesRule: outputs.tls.GetRuleContainerRuleKubernetesRule;
+        /**
+         * 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: string;
+    }
+    interface GetRuleContainerRuleEnvTag {
+        /**
+         * Key.
+         */
+        key: string;
+        /**
+         * Value.
+         */
+        val: string;
+    }
+    interface GetRuleContainerRuleExcludeContainerEnvRegex {
+        /**
+         * Key.
+         */
+        key: string;
+        /**
+         * Value.
+         */
+        val: string;
+    }
+    interface GetRuleContainerRuleExcludeContainerLabelRegex {
+        /**
+         * Key.
+         */
+        key: string;
+        /**
+         * Value.
+         */
+        val: string;
+    }
+    interface GetRuleContainerRuleIncludeContainerEnvRegex {
+        /**
+         * Key.
+         */
+        key: string;
+        /**
+         * Value.
+         */
+        val: string;
+    }
+    interface GetRuleContainerRuleIncludeContainerLabelRegex {
+        /**
+         * Key.
+         */
+        key: string;
+        /**
+         * Value.
+         */
+        val: string;
+    }
+    interface GetRuleContainerRuleKubernetesRule {
+        /**
+         * Whether to add Kubernetes Annotations as log tags to the original log data. When enabled, the log service will add fields related to Kubernetes Pod Annotations to the logs. Setting multiple key-value pairs means adding multiple fields. For example, if you set Key to sink and Value to data_sink, and the Pod contains the annotation sink=ck, a new field **tag**data_sink_*: ck will be added to the log.
+         */
+        annotationTags: outputs.tls.GetRuleContainerRuleKubernetesRuleAnnotationTag[];
+        /**
+         * 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: boolean;
+        /**
+         * Pod Annotation Denylist is used to specify containers that are not collected. If you need to set a Pod Annotation Denylist, Key is required and Value is optional. If Value is empty, all containers under Pods whose Pod Annotation contains the specified Key are excluded. If Value is not empty, only containers under Pods whose Pod Annotation contains the Key and whose value matches the specified Value are excluded. By default, Value uses string matching, meaning it only matches when Value and the Pod Annotation value are exactly the same. If the value starts with ^ and ends with $, it is treated as a regular expression. For example, if Key is set to app and Value is set to ^(test1|test2)$, it matches containers under Pods with Pod Annotation app:test1 or app:test2. Note: The logical relationship between multiple Key-Value pairs is OR, meaning a Pod Annotation that matches any pair will be excluded from the collection scope. When enabling the Pod Annotation Denylist, Keys must not be duplicated. For regex fuzzy matching, you must add .*. For example, ^(http.*)$ matches strings starting with http
+         */
+        excludePodAnnotationRegexes: outputs.tls.GetRuleContainerRuleKubernetesRuleExcludePodAnnotationRegex[];
+        /**
+         * Specify containers to exclude from collection using the Pod Label denylist. If not enabled, all containers are collected. To set a Pod Label denylist, Key is required and Value is optional. If Value is empty, all containers with the specified Key in their Pod Label are excluded from collection. If Value is not empty, only containers with the specified Key and a Value matching the Value in their Pod Label are excluded. Value supports regular expressions. For example, set Key to module and Value to ^(tcp|udp)$ to exclude containers with module:tcp or module:udp in their Pod Label. Note: The logical relationship between multiple Key-Value pairs is OR. Any Pod Label matching any Key-Value pair will be excluded from collection. When enabling the Pod Label denylist, Keys must not be duplicated. For fuzzy regular expression matching, you must add .*. For example, ^(http.*)$ matches any string starting with http
+         */
+        excludePodLabelRegexes: outputs.tls.GetRuleContainerRuleKubernetesRuleExcludePodLabelRegex[];
+        /**
+         * Pod Annotation Allowlist is used to specify containers to be collected. If you need to set a Pod Annotation Allowlist, Key is required and Value is optional. If Value is empty, all containers under Pods that contain the Key in Pod Annotation will match. If Value is not empty, only containers under Pods that contain the Key and whose value matches Value in Pod Annotation will match. Value defaults to string matching, meaning only when Value and the Pod Annotation value are exactly the same will they match. If the value starts with ^ and ends with $, it is a regex match. For example, set Key to app and Value to ^(test1|test2)$ to match containers under Pods with Pod Annotation app:test1 or app:test2. Note: The logical relationship between multiple Key-Value pairs is OR, meaning as long as Pod Annotation matches any pair, it will be included in the collection scope. When enabling Pod Annotation Allowlist, Keys must not be duplicated. For regex fuzzy matching, you must add .*. For example, ^(http.*)$ matches strings starting with http.
+         */
+        includePodAnnotationRegexes: outputs.tls.GetRuleContainerRuleKubernetesRuleIncludePodAnnotationRegex[];
+        /**
+         * Pod Label Allowlist is used to specify which containers to collect. If Pod Label Allowlist is not enabled, all containers will be collected. If you need to set a Pod Label Allowlist, Key is required: if Value is empty, all containers with the Key in their Pod Label will be collected. If Value is not empty, only containers with the Key in their Pod Label and a Value matching the specified pattern will be collected; regular expression matching is supported. For example, if you set Key to module and Value to ^(tcp|udp)$, only containers with module:tcp or module:udp in their Pod Label will be collected. Note: The logical relationship between multiple key-value pairs is OR, meaning any Pod Label matching any key-value pair will be included in the collection scope. When enabling Pod Label Allowlist, Keys cannot be duplicated. For fuzzy regular expression matching, you must add .*, for example, ^(http.*)$ matches strings starting with http.
+         */
+        includePodLabelRegexes: outputs.tls.GetRuleContainerRuleKubernetesRuleIncludePodLabelRegex[];
+        /**
+         * Whether to add Kubernetes labels as log tags to the raw log data. When enabled, the log service adds Kubernetes Pod label fields to the logs. Setting multiple key-value pairs adds multiple fields. For example, if you set Key to source and Value to data_source, and the Pod contains the label source=DC, the log will include the field **tag**data_source_*: DC.
+         */
+        labelTags: outputs.tls.GetRuleContainerRuleKubernetesRuleLabelTag[];
+        /**
+         * 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: 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: 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: 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: string;
+    }
+    interface GetRuleContainerRuleKubernetesRuleAnnotationTag {
+        /**
+         * Key.
+         */
+        key: string;
+        /**
+         * Value.
+         */
+        val: string;
+    }
+    interface GetRuleContainerRuleKubernetesRuleExcludePodAnnotationRegex {
+        /**
+         * Key.
+         */
+        key: string;
+        /**
+         * Value.
+         */
+        val: string;
+    }
+    interface GetRuleContainerRuleKubernetesRuleExcludePodLabelRegex {
+        /**
+         * Key.
+         */
+        key: string;
+        /**
+         * Value.
+         */
+        val: string;
+    }
+    interface GetRuleContainerRuleKubernetesRuleIncludePodAnnotationRegex {
+        /**
+         * Key.
+         */
+        key: string;
+        /**
+         * Value.
+         */
+        val: string;
+    }
+    interface GetRuleContainerRuleKubernetesRuleIncludePodLabelRegex {
+        /**
+         * Key.
+         */
+        key: string;
+        /**
+         * Value.
+         */
+        val: string;
+    }
+    interface GetRuleContainerRuleKubernetesRuleLabelTag {
+        /**
+         * Key.
+         */
+        key: string;
+        /**
+         * Value.
+         */
+        val: string;
+    }
+    interface GetRuleExcludePath {
+        /**
+         * Collection path type. File: File name. Path: Directory.
+         */
+        type: 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: string;
+    }
+    interface GetRuleExtractRule {
+        /**
+         * 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: string;
+        /**
+         * Log delimiter. Valid only when LogType is delimiter_log.
+         */
+        delimiter: 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: boolean;
+        /**
+         * Filter rule list. When LogType is minimalist*log or multiline*log, you can configure up to 1 filter rule, and the filter field name key must be content. When LogType is delimiter*log, json*log, or fullregex*log, you can configure up to 5 filter rules, and the filter field name key cannot be duplicated or empty. The regular expression for the filter field's log content must be a valid regular expression and is limited to 256 characters.
+         */
+        filterKeyRegexes: outputs.tls.GetRuleExtractRuleFilterKeyRegex[];
+        /**
+         * 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: 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: string;
+        /**
+         * Automatically extract log fields based on the specified log template
+         */
+        logTemplate: outputs.tls.GetRuleExtractRuleLogTemplate;
+        /**
+         * 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: string;
+        /**
+         * Regular expression for extracting time, used to extract the time value from the TimeKey field and parse it as the collection time
+         */
+        timeExtractRegex: 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: 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: string;
+        /**
+         * Time sample. Used to check whether the entered time parsing format is correct.
+         */
+        timeSample: 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: string;
+        /**
+         * Key name for unmatched logs.
+         */
+        unMatchLogKey: string;
+        /**
+         * Switch for uploading unmatched logs.
+         */
+        unMatchUpLoadSwitch: boolean;
+    }
+    interface GetRuleExtractRuleFilterKeyRegex {
+        /**
+         * Name of the filter field.
+         */
+        key: string;
+        /**
+         * The log content of the filter field must match the specified regular expression.
+         */
+        regex: string;
+    }
+    interface GetRuleExtractRuleLogTemplate {
+        /**
+         * Log template format.
+         */
+        format: string;
+        /**
+         * Log template types. Supported types: Nginx: Nginx log template.
+         */
+        type: string;
+    }
+    interface GetRuleHostGroupInfo {
+        /**
+         * Number of hosts with heartbeat exceptions.
+         */
+        abnormalHeartbeatStatusCount: number;
+        /**
+         * Latest agent version.
+         */
+        agentLatestVersion: string;
+        /**
+         * Whether LogCollector installed on the machine group server has automatic upgrade enabled. true: The log service will check for upgrades during a specified time period each day. If upgrade conditions are met, LogCollector will be upgraded automatically without manual intervention. false (default): LogCollector does not upgrade automatically. To use a newer version of LogCollector, refer to the LogCollector upgrade procedure.
+         */
+        autoUpdate: boolean;
+        /**
+         * Machine group creation time.
+         */
+        createTime: string;
+        /**
+         * Number of hosts.
+         */
+        hostCount: number;
+        /**
+         * Machine group ID
+         */
+        hostGroupId: string;
+        /**
+         * Name of the machine group.
+         */
+        hostGroupName: string;
+        /**
+         * Machine group type. IP: Machine IP. Label: Machine label.
+         */
+        hostGroupType: string;
+        /**
+         * Machine identifier.
+         */
+        hostIdentifier: string;
+        /**
+         * The IAM project to which the host group belongs.
+         */
+        iamProjectName: string;
+        /**
+         * Time when the machine group was modified.
+         */
+        modifyTime: string;
+        /**
+         * Number of hosts with normal heartbeat.
+         */
+        normalHeartbeatStatusCount: number;
+        /**
+         * The number of bound collection configurations.
+         */
+        ruleCount: number;
+        /**
+         * Whether to enable the Logcollector service log feature. true: enabled. false (default): disabled.
+         */
+        serviceLogging: boolean;
+        /**
+         * End time for LogCollector automatic upgrade.
+         */
+        updateEndTime: string;
+        /**
+         * LogCollector auto-update start time. Note: Only required when AutoUpdate is set to true. It is recommended to schedule auto-updates during off-peak hours. LogCollector may restart during the update process, but logs will not be lost.
+         */
+        updateStartTime: string;
+    }
+    interface GetRuleUserDefineRule {
+        /**
+         * 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: outputs.tls.GetRuleUserDefineRuleAdvanced;
+        /**
+         * 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: 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: boolean;
+        /**
+         * Upload raw logs. true: Upload raw logs. false (default): Do not upload raw logs.
+         */
+        enableRawLog: boolean;
+        /**
+         * Add constant fields to logs. Constant fields must follow these restrictions: You can upload up to 5 constant fields. Field names (Key) must be unique and not empty. Length limit: 1–128 characters, including letters, numbers, and special characters (-*./), and cannot start with an underscore. Field values (Value) must not be empty, with a maximum length of 512 KiB.
+         */
+        fields: outputs.tls.GetRuleUserDefineRuleField[];
+        /**
+         * Field name used to store machine group label information
+         */
+        hostGroupLabelKey: string;
+        /**
+         * Hostname field name. Required only when EnableHostname is true.
+         */
+        hostnameKey: string;
+        /**
+         * Ignore log files that have not been updated for a specified period (in hours).
+         */
+        ignoreOlder: number;
         /**
-         * Whether to distinguish case. Default is false.
+         * 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.
          */
-        caseSensitive: boolean;
+        multiCollectsType: 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.
+         * 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.
          */
-        delimiter: string;
+        parsePathRule: outputs.tls.GetRuleUserDefineRuleParsePathRule;
         /**
-         * 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.
+         * LogCollector plugin configuration. After enabling plugin configuration, you can add one or more LogCollector processor plugins to parse logs with complex or variable structures.
          */
-        includeChinese: boolean;
+        plugin: outputs.tls.GetRuleUserDefineRulePlugin;
         /**
-         * Create indexes for all fields with text values in the JSON field.
+         * 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.
          */
-        indexAll: boolean;
+        rawLogKey: string;
         /**
-         * Enable automatic indexing and statistics for JSON fields. true: Enable automatic indexing and statistics. false: Disable automatic indexing and statistics.
+         * 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
          */
-        indexSqlAll: boolean;
+        shardHashKey: outputs.tls.GetRuleUserDefineRuleShardHashKey;
         /**
-         * 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 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.
          */
-        sqlFlag: boolean;
+        tailFiles: 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.
+         * 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.
          */
-        valueType: string;
+        tailSizeKb: number;
     }
-    interface GetIndexUserInnerKeyValue {
+    interface GetRuleUserDefineRuleAdvanced {
         /**
-         * 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.
+         * After reading to the end of the log file, choose whether to release the file handle. Default is false.
+         */
+        closeEof: boolean;
+        /**
+         * 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.
+         */
+        closeInactive: number;
+        /**
+         * Release the file handle after the log file is removed. Default is false.
+         */
+        closeRemoved: boolean;
+        /**
+         * Release the file handle after the log file is renamed. Default is false.
+         */
+        closeRenamed: boolean;
+        /**
+         * 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.
+         */
+        closeTimeout: 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: number;
+    }
+    interface GetRuleUserDefineRuleField {
+        /**
+         * Key.
          */
         key: string;
         /**
-         * Field description information required for configuring key-value indexes.
+         * Value.
          */
-        value: outputs.tls.GetIndexUserInnerKeyValueValue;
+        val: string;
     }
-    interface GetIndexUserInnerKeyValueValue {
+    interface GetRuleUserDefineRuleParsePathRule {
         /**
-         * 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: boolean;
+        keys: string[];
         /**
-         * Whether to distinguish case. Default is false.
+         * Sample collection path for actual scenarios. The sample collection path must be an absolute path. Wildcards *, ?, ** are not allowed in the path sample.
          */
-        caseSensitive: boolean;
+        pathSample: 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.
+         * Regular expression used to extract the path field. Must match the sample collection path, otherwise extraction will fail
          */
-        delimiter: string;
+        regex: string;
+    }
+    interface GetRuleUserDefineRulePlugin {
         /**
-         * 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.
+         * LogCollector plugin. For the list of supported plugins and parameter descriptions, see LogCollector plugin overview.
          */
-        includeChinese: boolean;
+        processors: string;
+    }
+    interface GetRuleUserDefineRuleShardHashKey {
         /**
-         * Create indexes for all fields with text values in the JSON field.
+         * 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).
          */
-        indexAll: boolean;
+        hashKey: string;
+    }
+    interface GetScheduleSqlTaskRequestCycle {
         /**
-         * Enable automatic indexing and statistics for JSON fields. true: Enable automatic indexing and statistics. false: Disable automatic indexing and statistics.
+         * Cron expression, with a minimum granularity of minutes, using 24-hour format. For example, 0 18 * * * means execution at 18:00 every day.
          */
-        indexSqlAll: boolean;
+        cronTab: string;
         /**
-         * When ValueType is json, you can configure key-value indexes for JSON subfields using the JsonKeys field, which is an array of KeyValueInfo. Each element in the JsonKeys list is a KeyValueInfo, and you can further nest text, long, and double type subfields. For subfields in JSON key-value indexes, use . to indicate the hierarchy between JSON fields. For example, the JSON field namelist contains a text-type subfield totalcount and a JSON-type info, which itself contains the field name. Each field name should be configured as totalcount and info.name, respectively. The SqlFlag setting for subfield key-value indexes defined in JsonKeys must match their parent field, meaning they must be enabled or disabled together. The default is disabled. Subfields do not support separate settings for Delimiter, CaseSensitive, or IncludeChinese. For text-type fields, CaseSensitive, Delimiter, and IncludeChinese always inherit the parent field settings. This is only set when ValueType is json.
+         * If Type is set to Cron, you must also set the time zone.
          */
-        jsonKeys: outputs.tls.GetIndexUserInnerKeyValueValueJsonKey[];
+        cronTimeZone: 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.
+         * Scheduling period or the time point for periodic execution (minutes from 00:00). Range: 1–1440 minutes.
          */
-        sqlFlag: boolean;
+        time: number;
         /**
-         * 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.
+         * Scheduling period type. Options: Period, Fixed, Cron.
          */
-        valueType: string;
+        type: string;
     }
-    interface GetIndexUserInnerKeyValueValueJsonKey {
+    interface GetShipperContentInfo {
         /**
-         * 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.
+         * CSV format log content configuration.
          */
-        key: string;
+        csvInfo: outputs.tls.GetShipperContentInfoCsvInfo;
         /**
-         * Field description information required for configuring key-value indexes.
+         * Log content parsing format. Delivery to TOS supports json, jsonl, csv; delivery to Kafka supports original, json.
          */
-        value: outputs.tls.GetIndexUserInnerKeyValueValueJsonKeyValue;
+        format: string;
+        /**
+         * JSON/JSONL format log content configuration.
+         */
+        jsonInfo: outputs.tls.GetShipperContentInfoJsonInfo;
     }
-    interface GetIndexUserInnerKeyValueValueJsonKeyValue {
+    interface GetShipperContentInfoCsvInfo {
         /**
-         * Indicates whether the index was added automatically. true: The index was added automatically. false: The index was not added automatically.
+         * Delimiter. Supports comma, tab, pipe, semicolon, space.
          */
-        autoIndexFlag: boolean;
+        delimiter: string;
         /**
-         * Whether to distinguish case. Default is false.
+         * Escape character. When field content contains a delimiter, use an escape character to enclose it. Supports single quote, double quote, or empty character.
          */
-        caseSensitive: boolean;
+        escapeChar: 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.
+         * Fields to be delivered. Supports letters, numbers, and _-./. Cannot start with an underscore. Length: 1–128.
          */
-        delimiter: string;
+        keys: 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.
+         * Content for invalid field padding. Length: 0–128.
          */
-        includeChinese: boolean;
+        nonFieldContent: string;
         /**
-         * Create indexes for all fields with text values in the JSON field.
+         * Whether to print the key in the first row.
          */
-        indexAll: boolean;
+        printHeader: boolean;
+    }
+    interface GetShipperContentInfoJsonInfo {
         /**
-         * Enable automatic indexing and statistics for JSON fields. true: Enable automatic indexing and statistics. false: Disable automatic indexing and statistics.
+         * Enable flag.
          */
-        indexSqlAll: boolean;
+        enable: 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.
+         * Whether to enable escaping. Must be set to true.
          */
-        sqlFlag: boolean;
+        escape: 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.
+         * 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**.
          */
-        valueType: string;
+        keys: string[];
     }
-    interface GetProjectTag {
+    interface GetShipperKafkaShipperInfo {
         /**
-         * Tag key
+         * Compression format; supports snappy, gzip, lz4, none.
+         */
+        compress: string;
+        /**
+         * 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.
+         */
+        endTime: number;
+        /**
+         * Kafka instance.
+         */
+        instance: string;
+        /**
+         * Kafka topic name. All log data delivered through this configuration will be sent to this topic.
+         */
+        kafkaTopic: string;
+        /**
+         * 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.
+         */
+        startTime: number;
+    }
+    interface GetShipperTosShipperInfo {
+        /**
+         * 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.
+         */
+        bucket: string;
+        /**
+         * Compression format; supports snappy, gzip, lz4, none.
+         */
+        compress: string;
+        /**
+         * Delivery interval in seconds, range: 300–900.
+         */
+        interval: number;
+        /**
+         * Maximum raw file size per partition for delivery, in MiB. Range: 5–256.
+         */
+        maxSize: number;
+        /**
+         * Partition rule for log delivery. Subdirectory naming format supports strftime syntax. Default: %Y/%m/%d/%H/%M.
+         */
+        partitionFormat: string;
+        /**
+         * 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.
+         */
+        prefix: string;
+    }
+    interface GetTopicTag {
+        /**
+         * User tag key.
          */
         key: string;
         /**
-         * Tag value
+         * User tag value.
          */
         value: string;
     }
-    interface GetRuleContainerRule {
+    interface HostGroupRule {
         /**
-         * 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.
+         * Container collection rules
          */
-        containerNameRegex: string;
+        containerRule: outputs.tls.HostGroupRuleContainerRule;
         /**
-         * Whether to add environment variables as log tags to the raw log data. When enabled, the log service adds container environment variable fields to the logs. Setting multiple key-value pairs adds multiple fields. For example, set Key to source and Value to data_source. If the container has the environment variable source=DC, the log will include the field **tag**data_source_*: DC
+         * Time when the collection configuration was created.
          */
-        envTags: outputs.tls.GetRuleContainerRuleEnvTag[];
+        createTime: string;
+        excludePaths: outputs.tls.HostGroupRuleExcludePath[];
         /**
-         * The container environment variable denylist specifies which containers are excluded from collection. If the denylist is not enabled, all containers are collected. When the container environment variable denylist is enabled, Key is required and Value is optional. If Value is empty, all containers whose environment variables contain the Key are excluded from collection. If Value is not empty, only containers with a matching key-value pair are excluded, meaning only containers whose environment variables contain the Key and whose value matches the Value are excluded. Value supports regular expressions. For example, if Key is set to module and Value is set to ^(tcp|udp)$, containers with environment variables module:tcp or module:udp are excluded from collection. Multiple key-value pairs are evaluated with a logical OR, so any container environment variable matching any key-value pair will be excluded from collection. When the container environment variable denylist is enabled, Keys must be unique.
+         * Extraction rules
          */
-        excludeContainerEnvRegexes: outputs.tls.GetRuleContainerRuleExcludeContainerEnvRegex[];
+        extractRule: outputs.tls.HostGroupRuleExtractRule;
         /**
-         * Container label denylist specifies containers to exclude from collection. If the denylist is not enabled, all containers will be collected. If the container label denylist is enabled, Key is required and Value is optional. If Value is empty, all containers with the Key in their label will be excluded. If Value is not empty, only containers matching the key-value pair will be excluded—that is, containers with the Key in their label and a Value matching the specified pattern. Value supports regex matching; for example, set Key to app and Value to ^(test1|test2)$ to exclude containers with labels app:test1 and app:test2. Multiple key-value pairs use logical OR; any container label matching any pair will be excluded from collection. When the container label denylist is enabled, Keys must not be duplicated.
+         * Collection type. 0: Host log file. 1: K8s container standard output. 2: Log file inside K8s container.
          */
-        excludeContainerLabelRegexes: outputs.tls.GetRuleContainerRuleExcludeContainerLabelRegex[];
+        inputType: number;
         /**
-         * The container environment variable allowlist specifies which containers to collect using container environment variables. If the allowlist is not enabled, all containers are collected. When the container environment variable allowlist is enabled, you must enter key-value pairs. Key is required; Value is optional. If Value is empty, all containers containing the Key in their environment variables are collected. If Value is not empty, only containers with the Key in their environment variables and a Value matching the specified value are collected. Value supports regular expression matching. For example, if Key is set to module and Value is set to ^(tcp|udp)$, only containers with module:tcp or module:udp in their environment variables are collected. The logical relationship between multiple key-value pairs is OR, meaning any container environment variable matching any key-value pair will be included in the collection scope. When the container environment variable allowlist is enabled, Keys must not be duplicated.
+         * Log sample.
          */
-        includeContainerEnvRegexes: outputs.tls.GetRuleContainerRuleIncludeContainerEnvRegex[];
+        logSample: string;
         /**
-         * The container label allowlist specifies which containers to collect based on container labels. If the allowlist is not enabled, all containers are collected. When the container label allowlist is enabled, you must specify key-value pairs. Key is required and Value is optional. If Value is empty, all containers whose labels contain the Key are collected. If Value is not empty, only containers whose labels contain the Key and whose value matches the Value are collected. Value supports regular expressions. For example, if Key is set to app and Value is set to ^(test1|test2)$, only containers with labels app:test1 or app:test2 are collected. Multiple key-value pairs are evaluated with a logical OR, so any container label matching any key-value pair will be included in the collection scope. When the container label allowlist is enabled, Keys must be unique.
+         * Collection modes. minimalist*log: single-line full mode. json*log: JSON mode. delimiter*log: delimiter mode. multiline*log: multi-line full mode. fullregex_log: full regex mode.
          */
-        includeContainerLabelRegexes: outputs.tls.GetRuleContainerRuleIncludeContainerLabelRegex[];
+        logType: string;
+        /**
+         * Time when the collection configuration was modified.
+         */
+        modifyTime: string;
+        /**
+         * Data collection path list
+         */
+        paths: string[];
+        /**
+         * Running status of the collection configuration. 0: Running. 1: Paused.
+         */
+        pause: number;
+        /**
+         * Collection configuration ID.
+         */
+        ruleId: string;
+        /**
+         * Name of the collection configuration.
+         */
+        ruleName: string;
+        /**
+         * ID of the log topic to which the collection configuration belongs.
+         */
+        topicId: string;
+        /**
+         * Name of the log topic associated with the collection configuration
+         */
+        topicName: string;
+        /**
+         * User-defined collection rules.
+         */
+        userDefineRule: outputs.tls.HostGroupRuleUserDefineRule;
+    }
+    interface HostGroupRuleContainerRule {
+        /**
+         * Container name to collect. If no container name is specified, all containers in the machine group are collected. Supports regular expressions. For example, setting the container name to ^(container-test)$ collects all containers named container-test.
+         */
+        containerNameRegex: string;
+        envTags: outputs.tls.HostGroupRuleContainerRuleEnvTag[];
+        excludeContainerEnvRegexes: outputs.tls.HostGroupRuleContainerRuleExcludeContainerEnvRegex[];
+        excludeContainerLabelRegexes: outputs.tls.HostGroupRuleContainerRuleExcludeContainerLabelRegex[];
+        includeContainerEnvRegexes: outputs.tls.HostGroupRuleContainerRuleIncludeContainerEnvRegex[];
+        includeContainerLabelRegexes: outputs.tls.HostGroupRuleContainerRuleIncludeContainerLabelRegex[];
         /**
          * Kubernetes container collection rules.
          */
-        kubernetesRule: outputs.tls.GetRuleContainerRuleKubernetesRule;
+        kubernetesRule: outputs.tls.HostGroupRuleContainerRuleKubernetesRule;
         /**
-         * 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).
+         * Collection information. stdout: Container standard output (stdout). stderr: Container standard error (stderr). all: Both container standard output (stdout) and standard error (stderr).
          */
         stream: string;
     }
-    interface GetRuleContainerRuleEnvTag {
+    interface HostGroupRuleContainerRuleEnvTag {
         /**
          * Key.
          */
@@ -22157,7 +23665,7 @@ export declare namespace tls {
          */
         val: string;
     }
-    interface GetRuleContainerRuleExcludeContainerEnvRegex {
+    interface HostGroupRuleContainerRuleExcludeContainerEnvRegex {
         /**
          * Key.
          */
@@ -22167,7 +23675,7 @@ export declare namespace tls {
          */
         val: string;
     }
-    interface GetRuleContainerRuleExcludeContainerLabelRegex {
+    interface HostGroupRuleContainerRuleExcludeContainerLabelRegex {
         /**
          * Key.
          */
@@ -22177,7 +23685,7 @@ export declare namespace tls {
          */
         val: string;
     }
-    interface GetRuleContainerRuleIncludeContainerEnvRegex {
+    interface HostGroupRuleContainerRuleIncludeContainerEnvRegex {
         /**
          * Key.
          */
@@ -22187,7 +23695,7 @@ export declare namespace tls {
          */
         val: string;
     }
-    interface GetRuleContainerRuleIncludeContainerLabelRegex {
+    interface HostGroupRuleContainerRuleIncludeContainerLabelRegex {
         /**
          * Key.
          */
@@ -22197,41 +23705,23 @@ export declare namespace tls {
          */
         val: string;
     }
-    interface GetRuleContainerRuleKubernetesRule {
-        /**
-         * Whether to add Kubernetes Annotations as log tags to the original log data. When enabled, the log service will add fields related to Kubernetes Pod Annotations to the logs. Setting multiple key-value pairs means adding multiple fields. For example, if you set Key to sink and Value to data_sink, and the Pod contains the annotation sink=ck, a new field **tag**data_sink_*: ck will be added to the log.
-         */
-        annotationTags: outputs.tls.GetRuleContainerRuleKubernetesRuleAnnotationTag[];
+    interface HostGroupRuleContainerRuleKubernetesRule {
+        annotationTags: outputs.tls.HostGroupRuleContainerRuleKubernetesRuleAnnotationTag[];
         /**
-         * 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.
+         * Whether to add all Kubernetes Labels as log tags to the raw log data. When enabled, the log service adds fields for all Labels in the Kubernetes Pod to the log. For example, if the Pod has Label source=DC and destination=CS, the log will include fields **tag**source__: DC and **tag**destination__: CS.
          */
         enableAllLabelTag: boolean;
+        excludePodAnnotationRegexes: outputs.tls.HostGroupRuleContainerRuleKubernetesRuleExcludePodAnnotationRegex[];
+        excludePodLabelRegexes: outputs.tls.HostGroupRuleContainerRuleKubernetesRuleExcludePodLabelRegex[];
+        includePodAnnotationRegexes: outputs.tls.HostGroupRuleContainerRuleKubernetesRuleIncludePodAnnotationRegex[];
+        includePodLabelRegexes: outputs.tls.HostGroupRuleContainerRuleKubernetesRuleIncludePodLabelRegex[];
+        labelTags: outputs.tls.HostGroupRuleContainerRuleKubernetesRuleLabelTag[];
         /**
-         * Pod Annotation Denylist is used to specify containers that are not collected. If you need to set a Pod Annotation Denylist, Key is required and Value is optional. If Value is empty, all containers under Pods whose Pod Annotation contains the specified Key are excluded. If Value is not empty, only containers under Pods whose Pod Annotation contains the Key and whose value matches the specified Value are excluded. By default, Value uses string matching, meaning it only matches when Value and the Pod Annotation value are exactly the same. If the value starts with ^ and ends with $, it is treated as a regular expression. For example, if Key is set to app and Value is set to ^(test1|test2)$, it matches containers under Pods with Pod Annotation app:test1 or app:test2. Note: The logical relationship between multiple Key-Value pairs is OR, meaning a Pod Annotation that matches any pair will be excluded from the collection scope. When enabling the Pod Annotation Denylist, Keys must not be duplicated. For regex fuzzy matching, you must add .*. For example, ^(http.*)$ matches strings starting with http
-         */
-        excludePodAnnotationRegexes: outputs.tls.GetRuleContainerRuleKubernetesRuleExcludePodAnnotationRegex[];
-        /**
-         * Specify containers to exclude from collection using the Pod Label denylist. If not enabled, all containers are collected. To set a Pod Label denylist, Key is required and Value is optional. If Value is empty, all containers with the specified Key in their Pod Label are excluded from collection. If Value is not empty, only containers with the specified Key and a Value matching the Value in their Pod Label are excluded. Value supports regular expressions. For example, set Key to module and Value to ^(tcp|udp)$ to exclude containers with module:tcp or module:udp in their Pod Label. Note: The logical relationship between multiple Key-Value pairs is OR. Any Pod Label matching any Key-Value pair will be excluded from collection. When enabling the Pod Label denylist, Keys must not be duplicated. For fuzzy regular expression matching, you must add .*. For example, ^(http.*)$ matches any string starting with http
-         */
-        excludePodLabelRegexes: outputs.tls.GetRuleContainerRuleKubernetesRuleExcludePodLabelRegex[];
-        /**
-         * Pod Annotation Allowlist is used to specify containers to be collected. If you need to set a Pod Annotation Allowlist, Key is required and Value is optional. If Value is empty, all containers under Pods that contain the Key in Pod Annotation will match. If Value is not empty, only containers under Pods that contain the Key and whose value matches Value in Pod Annotation will match. Value defaults to string matching, meaning only when Value and the Pod Annotation value are exactly the same will they match. If the value starts with ^ and ends with $, it is a regex match. For example, set Key to app and Value to ^(test1|test2)$ to match containers under Pods with Pod Annotation app:test1 or app:test2. Note: The logical relationship between multiple Key-Value pairs is OR, meaning as long as Pod Annotation matches any pair, it will be included in the collection scope. When enabling Pod Annotation Allowlist, Keys must not be duplicated. For regex fuzzy matching, you must add .*. For example, ^(http.*)$ matches strings starting with http.
-         */
-        includePodAnnotationRegexes: outputs.tls.GetRuleContainerRuleKubernetesRuleIncludePodAnnotationRegex[];
-        /**
-         * Pod Label Allowlist is used to specify which containers to collect. If Pod Label Allowlist is not enabled, all containers will be collected. If you need to set a Pod Label Allowlist, Key is required: if Value is empty, all containers with the Key in their Pod Label will be collected. If Value is not empty, only containers with the Key in their Pod Label and a Value matching the specified pattern will be collected; regular expression matching is supported. For example, if you set Key to module and Value to ^(tcp|udp)$, only containers with module:tcp or module:udp in their Pod Label will be collected. Note: The logical relationship between multiple key-value pairs is OR, meaning any Pod Label matching any key-value pair will be included in the collection scope. When enabling Pod Label Allowlist, Keys cannot be duplicated. For fuzzy regular expression matching, you must add .*, for example, ^(http.*)$ matches strings starting with http.
-         */
-        includePodLabelRegexes: outputs.tls.GetRuleContainerRuleKubernetesRuleIncludePodLabelRegex[];
-        /**
-         * Whether to add Kubernetes labels as log tags to the raw log data. When enabled, the log service adds Kubernetes Pod label fields to the logs. Setting multiple key-value pairs adds multiple fields. For example, if you set Key to source and Value to data_source, and the Pod contains the label source=DC, the log will include the field **tag**data_source_*: DC.
-         */
-        labelTags: outputs.tls.GetRuleContainerRuleKubernetesRuleLabelTag[];
-        /**
-         * 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.
+         * Name of the Kubernetes Namespace to be collected. If not specified, all containers are collected. Namespace names support regular expression matching. For example, setting the Namespace name to ^(tcp|udp)$ collects all containers under the tcp and udp namespaces.
          */
         namespaceNameRegex: 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.
+         * Pod name is used to specify the Pod(s) to be collected. If the Pod name is not specified, all containers are collected. Pod name supports regex matching. For example, setting the Pod name to ^(http.*)$ collects all containers under Pods whose names start with http.
          */
         podNameRegex: string;
         /**
@@ -22239,11 +23729,11 @@ export declare namespace tls {
          */
         workloadNameRegex: 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
+         * Specify containers to collect by workload type. Only one type can be selected. If no type is specified, containers of all types will be collected. Supported workload types are: Deployment: stateless workload StatefulSet: stateful workload DaemonSet: daemon process Job: job CronJob: scheduled job
          */
         workloadType: string;
     }
-    interface GetRuleContainerRuleKubernetesRuleAnnotationTag {
+    interface HostGroupRuleContainerRuleKubernetesRuleAnnotationTag {
         /**
          * Key.
          */
@@ -22253,7 +23743,7 @@ export declare namespace tls {
          */
         val: string;
     }
-    interface GetRuleContainerRuleKubernetesRuleExcludePodAnnotationRegex {
+    interface HostGroupRuleContainerRuleKubernetesRuleExcludePodAnnotationRegex {
         /**
          * Key.
          */
@@ -22263,7 +23753,7 @@ export declare namespace tls {
          */
         val: string;
     }
-    interface GetRuleContainerRuleKubernetesRuleExcludePodLabelRegex {
+    interface HostGroupRuleContainerRuleKubernetesRuleExcludePodLabelRegex {
         /**
          * Key.
          */
@@ -22273,7 +23763,7 @@ export declare namespace tls {
          */
         val: string;
     }
-    interface GetRuleContainerRuleKubernetesRuleIncludePodAnnotationRegex {
+    interface HostGroupRuleContainerRuleKubernetesRuleIncludePodAnnotationRegex {
         /**
          * Key.
          */
@@ -22283,7 +23773,7 @@ export declare namespace tls {
          */
         val: string;
     }
-    interface GetRuleContainerRuleKubernetesRuleIncludePodLabelRegex {
+    interface HostGroupRuleContainerRuleKubernetesRuleIncludePodLabelRegex {
         /**
          * Key.
          */
@@ -22293,7 +23783,7 @@ export declare namespace tls {
          */
         val: string;
     }
-    interface GetRuleContainerRuleKubernetesRuleLabelTag {
+    interface HostGroupRuleContainerRuleKubernetesRuleLabelTag {
         /**
          * Key.
          */
@@ -22303,9 +23793,9 @@ export declare namespace tls {
          */
         val: string;
     }
-    interface GetRuleExcludePath {
+    interface HostGroupRuleExcludePath {
         /**
-         * Collection path type. File: File name. Path: Directory.
+         * Collection path type. File: file name. Path: directory.
          */
         type: string;
         /**
@@ -22313,9 +23803,9 @@ export declare namespace tls {
          */
         value: string;
     }
-    interface GetRuleExtractRule {
+    interface HostGroupRuleExtractRule {
         /**
-         * 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.
+         * The regex pattern required to match the first line of the log. This is valid only when LogType is multiline*log or fullregex*log. The pattern must be a valid regular expression.
          */
         beginRegex: string;
         /**
@@ -22323,59 +23813,56 @@ export declare namespace tls {
          */
         delimiter: 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.
+         * Enable nanosecond precision time. When enabled, log time parsing will report time with nanosecond precision. true: Enable nanosecond precision time. false: Disable nanosecond precision time.
          */
         enableNanosecond: boolean;
+        filterKeyRegexes: outputs.tls.HostGroupRuleExtractRuleFilterKeyRegex[];
         /**
-         * Filter rule list. When LogType is minimalist*log or multiline*log, you can configure up to 1 filter rule, and the filter field name key must be content. When LogType is delimiter*log, json*log, or fullregex*log, you can configure up to 5 filter rules, and the filter field name key cannot be duplicated or empty. The regular expression for the filter field's log content must be a valid regular expression and is limited to 256 characters.
-         */
-        filterKeyRegexes: outputs.tls.GetRuleExtractRuleFilterKeyRegex[];
-        /**
-         * 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.
+         * List of log field names (Keys).
          */
         keys: 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.
+         * The entire log entry must match the regular expression. This is only valid when the log type is fullregex_log. The regular expression must be valid.
          */
         logRegex: string;
         /**
-         * Automatically extract log fields based on the specified log template
+         * Automatically extract log fields based on the specified log template.
          */
-        logTemplate: outputs.tls.GetRuleExtractRuleLogTemplate;
+        logTemplate: outputs.tls.HostGroupRuleExtractRuleLogTemplate;
         /**
-         * 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.
+         * Quotation mark. Content enclosed by quotation marks is parsed as a complete field and not separated. Only valid when LogType is delimiter_log.
          */
         quote: string;
         /**
-         * Regular expression for extracting time, used to extract the time value from the TimeKey field and parse it as the collection time
+         * Regular expression for extracting time, used to extract the time value from the TimeKey field and parse it as the collection time.
          */
         timeExtractRegex: 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.
+         * Parsing format for the time field. If a specified time field in the log is used as the log timestamp, you must provide TimeKey and TimeFormat.
          */
         timeFormat: 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.
+         * Field name for the log time field. If a specified time field in the log is used as the log timestamp, you must provide TimeKey and TimeFormat.
          */
         timeKey: string;
         /**
-         * Time sample. Used to check whether the entered time parsing format is correct.
+         * Sample time. Used to verify whether the specified time parsing format is correct.
          */
         timeSample: 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.
+         * Time zone. Supports machine time zone (default) and custom time zone. Custom time zone supports GMT and UTC.
          */
         timeZone: string;
         /**
-         * Key name for unmatched logs.
+         * Key name for logs that failed to parse when uploading
          */
         unMatchLogKey: string;
         /**
-         * Switch for uploading unmatched logs.
+         * Upload logs that failed to parse. UnMatchUpLoadSwitch=true and UnMatchLogKey must be used together. true: Upload logs that failed to parse. false: Do not upload logs that failed to parse.
          */
         unMatchUpLoadSwitch: boolean;
     }
-    interface GetRuleExtractRuleFilterKeyRegex {
+    interface HostGroupRuleExtractRuleFilterKeyRegex {
         /**
          * Name of the filter field.
          */
@@ -22385,331 +23872,136 @@ export declare namespace tls {
          */
         regex: string;
     }
-    interface GetRuleExtractRuleLogTemplate {
-        /**
-         * Log template format.
-         */
-        format: string;
-        /**
-         * Log template types. Supported types: Nginx: Nginx log template.
-         */
-        type: string;
-    }
-    interface GetRuleHostGroupInfo {
-        /**
-         * Number of hosts with heartbeat exceptions.
-         */
-        abnormalHeartbeatStatusCount: number;
-        /**
-         * Latest agent version.
-         */
-        agentLatestVersion: string;
-        /**
-         * Whether LogCollector installed on the machine group server has automatic upgrade enabled. true: The log service will check for upgrades during a specified time period each day. If upgrade conditions are met, LogCollector will be upgraded automatically without manual intervention. false (default): LogCollector does not upgrade automatically. To use a newer version of LogCollector, refer to the LogCollector upgrade procedure.
-         */
-        autoUpdate: boolean;
-        /**
-         * Machine group creation time.
-         */
-        createTime: string;
-        /**
-         * Number of hosts.
-         */
-        hostCount: number;
-        /**
-         * Machine group ID
-         */
-        hostGroupId: string;
-        /**
-         * Name of the machine group.
-         */
-        hostGroupName: string;
-        /**
-         * Machine group type. IP: Machine IP. Label: Machine label.
-         */
-        hostGroupType: string;
-        /**
-         * Machine identifier.
-         */
-        hostIdentifier: string;
-        /**
-         * The IAM project to which the host group belongs.
-         */
-        iamProjectName: string;
-        /**
-         * Time when the machine group was modified.
-         */
-        modifyTime: string;
-        /**
-         * Number of hosts with normal heartbeat.
-         */
-        normalHeartbeatStatusCount: number;
-        /**
-         * The number of bound collection configurations.
-         */
-        ruleCount: number;
-        /**
-         * Whether to enable the Logcollector service log feature. true: enabled. false (default): disabled.
-         */
-        serviceLogging: boolean;
-        /**
-         * End time for LogCollector automatic upgrade.
-         */
-        updateEndTime: string;
-        /**
-         * LogCollector auto-update start time. Note: Only required when AutoUpdate is set to true. It is recommended to schedule auto-updates during off-peak hours. LogCollector may restart during the update process, but logs will not be lost.
-         */
-        updateStartTime: string;
-    }
-    interface GetRuleUserDefineRule {
-        /**
-         * 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: outputs.tls.GetRuleUserDefineRuleAdvanced;
-        /**
-         * 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: 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: boolean;
-        /**
-         * Upload raw logs. true: Upload raw logs. false (default): Do not upload raw logs.
-         */
-        enableRawLog: boolean;
-        /**
-         * Add constant fields to logs. Constant fields must follow these restrictions: You can upload up to 5 constant fields. Field names (Key) must be unique and not empty. Length limit: 1–128 characters, including letters, numbers, and special characters (-*./), and cannot start with an underscore. Field values (Value) must not be empty, with a maximum length of 512 KiB.
-         */
-        fields: outputs.tls.GetRuleUserDefineRuleField[];
-        /**
-         * Field name used to store machine group label information
-         */
-        hostGroupLabelKey: string;
-        /**
-         * Hostname field name. Required only when EnableHostname is true.
-         */
-        hostnameKey: string;
-        /**
-         * Ignore log files that have not been updated for a specified period (in hours).
-         */
-        ignoreOlder: number;
-        /**
-         * 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.
-         */
-        multiCollectsType: string;
-        /**
-         * 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.
-         */
-        parsePathRule: outputs.tls.GetRuleUserDefineRuleParsePathRule;
-        /**
-         * LogCollector plugin configuration. After enabling plugin configuration, you can add one or more LogCollector processor plugins to parse logs with complex or variable structures.
-         */
-        plugin: outputs.tls.GetRuleUserDefineRulePlugin;
-        /**
-         * 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.
-         */
-        rawLogKey: string;
-        /**
-         * Rules for routing log partitions. If this parameter is not set, logs are written using the default load balancing mode, and packets are written to any available Shard. If 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
-         */
-        shardHashKey: outputs.tls.GetRuleUserDefineRuleShardHashKey;
-        /**
-         * 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.
-         */
-        tailFiles: boolean;
-        /**
-         * 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.
-         */
-        tailSizeKb: number;
-    }
-    interface GetRuleUserDefineRuleAdvanced {
-        /**
-         * After reading to the end of the log file, choose whether to release the file handle. Default is false.
-         */
-        closeEof: boolean;
-        /**
-         * 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.
-         */
-        closeInactive: number;
-        /**
-         * Release the file handle after the log file is removed. Default is false.
-         */
-        closeRemoved: boolean;
-        /**
-         * Release the file handle after the log file is renamed. Default is false.
-         */
-        closeRenamed: boolean;
-        /**
-         * 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.
-         */
-        closeTimeout: 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: number;
-    }
-    interface GetRuleUserDefineRuleField {
-        /**
-         * Key.
-         */
-        key: string;
-        /**
-         * Value.
-         */
-        val: string;
-    }
-    interface GetRuleUserDefineRuleParsePathRule {
-        /**
-         * 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.
-         */
-        keys: string[];
-        /**
-         * Sample collection path for actual scenarios. The sample collection path must be an absolute path. Wildcards *, ?, ** are not allowed in the path sample.
-         */
-        pathSample: string;
-        /**
-         * Regular expression used to extract the path field. Must match the sample collection path, otherwise extraction will fail
-         */
-        regex: string;
-    }
-    interface GetRuleUserDefineRulePlugin {
-        /**
-         * LogCollector plugin. For the list of supported plugins and parameter descriptions, see LogCollector plugin overview.
-         */
-        processors: string;
-    }
-    interface GetRuleUserDefineRuleShardHashKey {
+    interface HostGroupRuleExtractRuleLogTemplate {
         /**
-         * 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).
+         * Log template format
          */
-        hashKey: string;
-    }
-    interface GetScheduleSqlTaskRequestCycle {
+        format: string;
         /**
-         * Cron expression, with a minimum granularity of minutes, using 24-hour format. For example, 0 18 * * * means execution at 18:00 every day.
+         * Log template type. Supported types: Nginx (Nginx log template type).
          */
-        cronTab: string;
+        type: string;
+    }
+    interface HostGroupRuleUserDefineRule {
         /**
-         * If Type is set to Cron, you must also set the time zone.
+         * Advanced parameters are used for extended configuration. After enabling extended configuration, you can customize advanced behaviors of LogCollector, such as when to release file handles. Note: If multiple conditions for releasing handles are specified, the handle will be released and log file monitoring will end as soon as any condition is met.
          */
-        cronTimeZone: string;
+        advanced: outputs.tls.HostGroupRuleUserDefineRuleAdvanced;
         /**
-         * Scheduling period or the time point for periodic execution (minutes from 00:00). Range: 1–1440 minutes.
+         * Whether to upload the Label information of the host group to the log service. Disabled by default. true: LogCollector uploads the Label information of the host group to the specified field. You can specify the field name in the HostGroupLabelKey parameter. false (default): LogCollector does not upload the Label information of the host group.
          */
-        time: number;
+        enableHostGroupLabel: boolean;
         /**
-         * Scheduling period type. Options: Period, Fixed, Cron.
+         * Whether to upload the hostname field. Default is disabled. true: Adds a field to the original log to record the log source's hostname. Specify the hostname field name using HostnameKey. false (default): Does not add the hostname field.
          */
-        type: string;
-    }
-    interface GetShipperContentInfo {
+        enableHostname: boolean;
         /**
-         * CSV format log content configuration.
+         * Whether to upload raw logs. true: Upload raw logs. false (default): Do not upload raw logs.
          */
-        csvInfo: outputs.tls.GetShipperContentInfoCsvInfo;
+        enableRawLog: boolean;
+        fields: outputs.tls.HostGroupRuleUserDefineRuleField[];
         /**
-         * Log content parsing format. Delivery to TOS supports json, jsonl, csv; delivery to Kafka supports original, json.
+         * Field name used to store machine group label information.
          */
-        format: string;
+        hostGroupLabelKey: string;
         /**
-         * JSON/JSONL format log content configuration.
+         * hostname field name. Only required when EnableHostname is set to true.
          */
-        jsonInfo: outputs.tls.GetShipperContentInfoJsonInfo;
-    }
-    interface GetShipperContentInfoCsvInfo {
+        hostnameKey: string;
         /**
-         * Delimiter. Supports comma, tab, pipe, semicolon, space.
+         * Ignore log files that have not been updated for a specified duration, in hours.
          */
-        delimiter: string;
+        ignoreOlder: number;
         /**
-         * Escape character. When field content contains a delimiter, use an escape character to enclose it. Supports single quote, double quote, or empty character.
+         * Allows multiple log file collections. Empty: Uses the log file ID (including file inode, device, and checksum of the first N bytes) to uniquely identify the log file. RuleID: Uses the collection rule ID and log file ID to uniquely identify the log file. TopicIDRuleName: Uses the log topic ID, collection rule Name, and log file ID to uniquely identify the log file.
          */
-        escapeChar: string;
+        multiCollectsType: string;
         /**
-         * Fields to be delivered. Supports letters, numbers, and _-./. Cannot start with an underscore. Length: 1–128.
+         * Rules for parsing the collection path. After setting the rule, fields in the collection path are extracted using the specified regex and added as metadata to the log data. Note: This parameter is not supported when collecting container standard output.
          */
-        keys: string[];
+        parsePathRule: outputs.tls.HostGroupRuleUserDefineRuleParsePathRule;
         /**
-         * Content for invalid field padding. Length: 0–128.
+         * LogCollector plugin configuration. After enabling plugin configuration, you can add one or more LogCollector processor plugins to parse logs with complex or variable structures.
          */
-        nonFieldContent: string;
+        plugin: outputs.tls.HostGroupRuleUserDefineRulePlugin;
         /**
-         * Whether to print the key in the first row.
+         * Original log field name. Only effective when EnableRawLog is set to true. RawLogKey defaults to **raw**, meaning the original log data will be encapsulated in the **raw** field and uploaded to the log service together with the parsed log data
          */
-        printHeader: boolean;
-    }
-    interface GetShipperContentInfoJsonInfo {
+        rawLogKey: string;
         /**
-         * Enable flag.
+         * Rules for routing log partitions. If this parameter is not set, logs are written using the default load balancing mode, and packets are written to any available Shard. If set, logs are collected using the HashKey routing Shard mode, and the log service writes data to the Shard containing the specified Key value.
          */
-        enable: boolean;
+        shardHashKey: outputs.tls.HostGroupRuleUserDefineRuleShardHashKey;
         /**
-         * Whether to enable escaping. Must be set to true.
+         * LogCollector collection strategy, specifying whether LogCollector collects incremental logs or full logs. The default is false, which means full log collection. true: incremental collection. When LogCollector collects logs, it only collects newly added content in the file. When a monitored log file receives new log entries, LogCollector is triggered to collect logs. For log files being collected for the first time, LogCollector automatically determines the collection position based on the incremental threshold TailSizeKb you specify. If the new file size does not exceed the incremental threshold, collection starts from the beginning of the new file. If the new file size exceeds the incremental threshold, collection starts from the position at the end of the file minus the incremental threshold, meaning only incremental logs are collected. For log files that are not being collected for the first time, LogCollector determines the collection position based on the Checkpoint and continues collecting. false: (default) full collection. LogCollector collects logs from the beginning of each file, including historical log data.
          */
-        escape: boolean;
+        tailFiles: 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**.
+         * Incremental collection backtracking threshold, in KiB. When LogCollector uses incremental collection, for the first collection of a log file: if the new log file size does not exceed the TailSizeKb value, collection starts from the beginning of the file. If the new log file size exceeds the TailSizeKb value, collection starts from the position TailSizeKb from the end of the file.
          */
-        keys: string[];
+        tailSizeKb: number;
     }
-    interface GetShipperKafkaShipperInfo {
+    interface HostGroupRuleUserDefineRuleAdvanced {
         /**
-         * Compression format; supports snappy, gzip, lz4, none.
+         * After reading to the end of the log file, whether to release the file handle. Default is false.
          */
-        compress: string;
+        closeEof: boolean;
         /**
-         * 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.
+         * Wait time before releasing log file handles. If no new logs are written to a log file for the specified duration, the handle for that log file is released. Unit: seconds. Range: 1–300 seconds. Default: 60 seconds.
          */
-        endTime: number;
+        closeInactive: number;
         /**
-         * Kafka instance.
+         * Whether to release the handle of the log file after it is removed. Default is false.
          */
-        instance: string;
+        closeRemoved: boolean;
         /**
-         * Kafka topic name. All log data delivered through this configuration will be sent to this topic.
+         * Whether to release the handle of the log file after it is renamed. Default is false.
          */
-        kafkaTopic: string;
+        closeRenamed: boolean;
         /**
-         * 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.
+         * Maximum duration for LogCollector to monitor log files, in seconds. The default is 0 seconds, meaning LogCollector does not limit the monitoring duration. Timing starts when LogCollector begins monitoring the log file. After the specified duration is exceeded, regardless of whether the log file has been fully read, LogCollector immediately releases the file handle and stops monitoring.
          */
-        startTime: number;
-    }
-    interface GetShipperTosShipperInfo {
+        closeTimeout: number;
         /**
-         * 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.
+         * Maximum wait time when LogCollector does not read a line break. Unit: seconds. Default: 5s. LogCollector starts timing when it begins reading log file content. If no line break is read within the specified time, it will send the buffered logs. If the file write interval is large, a complete log entry may be split into two parts and written separately. Adjust this parameter based on your log write interval.
          */
-        bucket: string;
+        noLineTerminatorEofMaxTime: number;
+    }
+    interface HostGroupRuleUserDefineRuleField {
         /**
-         * Compression format; supports snappy, gzip, lz4, none.
+         * Key.
          */
-        compress: string;
+        key: string;
         /**
-         * Delivery interval in seconds, range: 300–900.
+         * Value.
          */
-        interval: number;
+        val: string;
+    }
+    interface HostGroupRuleUserDefineRuleParsePathRule {
         /**
-         * Maximum raw file size per partition for delivery, in MiB. Range: 5–256.
+         * List of field names. Log Service parses PathSample into multiple fields using regular expressions (Regex). Keys specify the name of each field. You can configure up to 100 field names. Field names cannot be empty or duplicated.
          */
-        maxSize: number;
+        keys: string[];
         /**
-         * Partition rule for log delivery. Subdirectory naming format supports strftime syntax. Default: %Y/%m/%d/%H/%M.
+         * Sample collection path for actual scenarios. The sample path must be an absolute path. Wildcards *, ?, ** are not allowed in the sample path.
          */
-        partitionFormat: string;
+        pathSample: string;
         /**
-         * 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.
+         * Regular expression used to extract the path field. It must match the example collection path; otherwise, extraction will fail.
          */
-        prefix: string;
+        regex: string;
     }
-    interface GetTopicTag {
+    interface HostGroupRuleUserDefineRulePlugin {
         /**
-         * User tag key.
+         * LogCollector plugins. For supported plugin lists and parameter descriptions, see LogCollector plugin overview.
          */
-        key: string;
+        processors: string;
+    }
+    interface HostGroupRuleUserDefineRuleShardHashKey {
         /**
-         * User tag value.
+         * The HashKey of the log group specifies the shard where the current log group will be written. The valid range for this parameter is [00000000000000000000000000000000-ffffffffffffffffffffffffffffffff).
          */
-        value: string;
+        hashKey: string;
     }
     interface ImportTaskImportSourceInfo {
         /**
@@ -23838,31 +25130,308 @@ export declare namespace tos {
         /**
          * Storage class. Includes STANDARD, IA, ARCHIVE*FR, INTELLIGENT*TIERING, COLD*ARCHIVE, ARCHIVE, DEEP*COLD_ARCHIVE
          */
-        storageClass: string;
+        storageClass: string;
+    }
+    interface BucketLifecycleConfigTag {
+        /**
+         * Tag key
+         */
+        key: string;
+        /**
+         * Tag value
+         */
+        value: string;
+    }
+    interface BucketLifecycleConfigTransition {
+        /**
+         * Specific date for latest version object transition in lifecycle rules based on last modified time
+         */
+        date: string;
+        /**
+         * Number of days to transition the latest version object in the lifecycle rule based on last modified time
+         */
+        days: number;
+        /**
+         * Storage class for historical version object transition in lifecycle rules based on last modified time. Includes STANDARD, IA, ARCHIVE*FR, INTELLIGENT*TIERING, COLD*ARCHIVE, ARCHIVE, DEEP*COLD_ARCHIVE
+         */
+        storageClass: string;
+    }
+    interface BucketMirrorBackRule {
+        /**
+         * Conditions that trigger the back-to-origin function.
+         */
+        condition: outputs.tos.BucketMirrorBackRuleCondition;
+        /**
+         * Rule ID. The unique identifier for the back-to-origin rule configured on the current bucket. You can set this yourself to distinguish between multiple rules. Restrictions:
+         * Characters supported: letters, numbers,   - and _.
+         * Maximum length: 32 characters.
+         */
+        id: string;
+        /**
+         * Back-to-origin redirect configuration.
+         */
+        redirect: outputs.tos.BucketMirrorBackRuleRedirect;
+    }
+    interface BucketMirrorBackRuleCondition {
+        /**
+         * Supports triggering origin fetch only for specified domains. The domain must be able to access the bucket; it is recommended to use a custom domain bound to the bucket. Limit: supports up to 30 domains.
+         */
+        allowHosts: string[];
+        /**
+         * Error code that triggers origin fetch. When a download request returns this error code, origin fetch is triggered. Limit: currently only supports 404.
+         */
+        httpCode: number;
+        /**
+         * Request types that trigger back-to-origin. Value description:
+         * ["GET","HEAD"]: Both GetObject and HeadObject requests can trigger back-to-origin.
+         * ["GET"]: Only GetObject requests can trigger back-to-origin.
+         * Default is ["GET"].
+         */
+        httpMethods: string[];
+        /**
+         * Object name prefix for matching origin fetch objects. Limit: supports up to 512 characters.
+         */
+        keyPrefix: string;
+        /**
+         * Object name suffix for matching origin fetch objects. Limit: supports up to 512 characters.
+         */
+        keySuffix: string;
+    }
+    interface BucketMirrorBackRuleRedirect {
+        fetchHeaderToMetaDataRules: outputs.tos.BucketMirrorBackRuleRedirectFetchHeaderToMetaDataRule[];
+        /**
+         * Whether to fetch data from the configured origin after redirection. Value description: true: Fetch data from the configured origin after redirection. false: Do not fetch data from the configured origin after redirection.
+         */
+        fetchSourceOnRedirect: boolean;
+        /**
+         * Whether to include request parameters when fetching data after redirection. If not configured, inherits PassQuery settings: true: includes request parameters. false: does not include request parameters.
+         */
+        fetchSourceOnRedirectWithQuery: boolean;
+        /**
+         * If the result of mirror origin fetch is 3xx, whether to continue redirecting to the specified Location to fetch data. Value description: true: TOS will continue to request the address corresponding to Location. false: TOS will return 302.
+         */
+        followRedirect: boolean;
+        /**
+         * Specify the headers to include when mirroring back to origin.
+         */
+        mirrorHeader: outputs.tos.BucketMirrorBackRuleRedirectMirrorHeader;
+        /**
+         * List of origin response headers allowed to be passed through directly.
+         */
+        passHeaderFromSources: string[];
+        /**
+         * Whether to include request parameters when performing redirect or mirror back-to-origin rules. Value description:
+         * true: Include request parameters.
+         * false: Do not include request parameters.
+         */
+        passQuery: boolean;
+        /**
+         * List of origin response status codes allowed to be passed through directly.
+         */
+        passStatusCodeFromSources: number[];
+        /**
+         * Back-to-origin address configuration when the origin server is a private bucket.
+         */
+        privateSource: outputs.tos.BucketMirrorBackRuleRedirectPrivateSource;
+        /**
+         * Back-to-origin address configuration when the origin server is a public bucket.
+         */
+        publicSource: outputs.tos.BucketMirrorBackRuleRedirectPublicSource;
+        /**
+         * Specify redirect type. Value range: Mirror: Mirror origin fetch. Async: Redirect origin fetch.
+         */
+        redirectType: string;
+        /**
+         * Define transformations for the object name when requesting the origin server.
+         */
+        transform: outputs.tos.BucketMirrorBackRuleRedirectTransform;
+    }
+    interface BucketMirrorBackRuleRedirectFetchHeaderToMetaDataRule {
+        /**
+         * Suffix appended when writing object metadata.
+         */
+        metaDataSuffix: string;
+        /**
+         * Origin response header name.
+         */
+        sourceHeader: string;
+    }
+    interface BucketMirrorBackRuleRedirectMirrorHeader {
+        /**
+         * Whether to forward all HTTP headers to the origin. Values: true: forwards all HTTP headers to the origin. false: does not forward all HTTP headers to the origin. The following HTTP header types are not supported for forwarding: Host, Content-Length, Date, Authorization.
+         */
+        passAll: boolean;
+        /**
+         * Pass the specified headers to the origin server. Limit: up to 64.
+         */
+        passes: string[];
+        /**
+         * Prohibit forwarding specified headers to the origin. Limit: maximum 64.
+         */
+        removes: string[];
+        sets: outputs.tos.BucketMirrorBackRuleRedirectMirrorHeaderSet[];
+    }
+    interface BucketMirrorBackRuleRedirectMirrorHeaderSet {
+        /**
+         * Request header name.
+         */
+        key: string;
+        /**
+         * Request header value.
+         */
+        value: string;
+    }
+    interface BucketMirrorBackRuleRedirectPrivateSource {
+        /**
+         * Back-to-origin address configuration when the origin server is a private bucket.
+         */
+        sourceEndpoint: outputs.tos.BucketMirrorBackRuleRedirectPrivateSourceSourceEndpoint;
+    }
+    interface BucketMirrorBackRuleRedirectPrivateSourceSourceEndpoint {
+        followers: outputs.tos.BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointFollower[];
+        primaries: outputs.tos.BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointPrimary[];
+    }
+    interface BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointFollower {
+        /**
+         * Name of the origin fetch bucket. Required when the origin is a private bucket.
+         */
+        bucketName: string;
+        /**
+         * Private back-to-origin authentication method. Required when the origin server is a private bucket.
+         */
+        credentialProvider: outputs.tos.BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointFollowerCredentialProvider;
+        /**
+         * Access domain name of the origin service provider, excluding bucket name, maximum length 255. Required for private buckets.
+         */
+        endpoint: string;
+    }
+    interface BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointFollowerCredentialProvider {
+        /**
+         * Region where the origin fetch bucket is located. Required when using AK/SK authentication.
+         */
+        region: string;
+        /**
+         * Name of AssumeRole. Only when fetching from a private TOS bucket can AssumeRole be used for authentication. Role authentication and AK/SK authentication are mutually exclusive and cannot be set simultaneously.
+         */
+        role: string;
+        /**
+         * Authenticate using AK/SK.
+         */
+        staticCredential: outputs.tos.BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointFollowerCredentialProviderStaticCredential;
+    }
+    interface BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointFollowerCredentialProviderStaticCredential {
+        /**
+         * AccessKey ID of the origin bucket. Required when using AK/SK authentication.
+         */
+        ak: string;
+        /**
+         * SecretKey for the back-to-origin bucket. Required when using AK/SK authentication.
+         */
+        sk: string;
+        /**
+         * Encryption method used for SecretKey. Values:
+         * Empty: SecretKey is in plaintext. After receiving the SecretKey, the server will encrypt and store it.
+         * AES256: SecretKey has been encrypted using the AES256 algorithm on the server side. After receiving the SecretKey, the server will parse and encrypt it for storage.
+         * Note: When a back-to-origin rule is created for the first time, the SecretKey is encrypted with AES256. If you modify the back-to-origin rule without changing the SecretKey parameter, you must first decrypt the SecretKey and then re-encrypt it for storage. Therefore, when calling the PutBucketMirrorBack API to modify the back-to-origin rule and only changing other parameters (not the SecretKey), you can set SKEncryptType to AES256.
+         */
+        skEncryptType: string;
+        /**
+         * Origin service provider. Values: BOS: Baidu Cloud. S3: Other cloud providers using the S3 storage protocol.
+         */
+        storageVendor: string;
+    }
+    interface BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointPrimary {
+        /**
+         * Name of the origin fetch bucket. Required when the origin is a private bucket.
+         */
+        bucketName: string;
+        /**
+         * Private back-to-origin authentication method. Required when the origin server is a private bucket.
+         */
+        credentialProvider: outputs.tos.BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointPrimaryCredentialProvider;
+        /**
+         * Access domain name of the origin service provider, excluding bucket name, maximum length 255. Required for private buckets.
+         */
+        endpoint: string;
+    }
+    interface BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointPrimaryCredentialProvider {
+        /**
+         * Region where the origin fetch bucket is located. Required when using AK/SK authentication.
+         */
+        region: string;
+        /**
+         * Name of AssumeRole. Only when fetching from a private TOS bucket can AssumeRole be used for authentication. Role authentication and AK/SK authentication are mutually exclusive and cannot be set simultaneously.
+         */
+        role: string;
+        /**
+         * Authenticate using AK/SK.
+         */
+        staticCredential: outputs.tos.BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointPrimaryCredentialProviderStaticCredential;
+    }
+    interface BucketMirrorBackRuleRedirectPrivateSourceSourceEndpointPrimaryCredentialProviderStaticCredential {
+        /**
+         * AccessKey ID of the origin bucket. Required when using AK/SK authentication.
+         */
+        ak: string;
+        /**
+         * SecretKey for the back-to-origin bucket. Required when using AK/SK authentication.
+         */
+        sk: string;
+        /**
+         * Encryption method used for SecretKey. Values:
+         * Empty: SecretKey is in plaintext. After receiving the SecretKey, the server will encrypt and store it.
+         * AES256: SecretKey has been encrypted using the AES256 algorithm on the server side. After receiving the SecretKey, the server will parse and encrypt it for storage.
+         * Note: When a back-to-origin rule is created for the first time, the SecretKey is encrypted with AES256. If you modify the back-to-origin rule without changing the SecretKey parameter, you must first decrypt the SecretKey and then re-encrypt it for storage. Therefore, when calling the PutBucketMirrorBack API to modify the back-to-origin rule and only changing other parameters (not the SecretKey), you can set SKEncryptType to AES256.
+         */
+        skEncryptType: string;
+        /**
+         * Origin service provider. Values: BOS: Baidu Cloud. S3: Other cloud providers using the S3 storage protocol.
+         */
+        storageVendor: string;
+    }
+    interface BucketMirrorBackRuleRedirectPublicSource {
+        /**
+         * Whether to always use the configured origin address.
+         */
+        fixedEndpoint: boolean;
+        /**
+         * Publicly accessible origin address.
+         */
+        sourceEndpoint: outputs.tos.BucketMirrorBackRuleRedirectPublicSourceSourceEndpoint;
+    }
+    interface BucketMirrorBackRuleRedirectPublicSourceSourceEndpoint {
+        /**
+         * Origin address. Limit: Maximum length 255, supports up to 5 origin fetch addresses. When all origin fetches fail in Primary, an origin is selected from this configuration.
+         */
+        followers: string[];
+        /**
+         * Origin address. Limit: Maximum length 255, supports up to 5 origin fetch addresses.
+         */
+        primaries: string[];
     }
-    interface BucketLifecycleConfigTag {
+    interface BucketMirrorBackRuleRedirectTransform {
         /**
-         * Tag key
+         * Object name prefix to be replaced when requesting the origin.
          */
-        key: string;
+        replaceKeyPrefix: outputs.tos.BucketMirrorBackRuleRedirectTransformReplaceKeyPrefix;
         /**
-         * Tag value
+         * Prefix added before the object name when requesting the origin server. Limit: up to 512 characters.
          */
-        value: string;
-    }
-    interface BucketLifecycleConfigTransition {
+        withKeyPrefix: string;
         /**
-         * Specific date for latest version object transition in lifecycle rules based on last modified time
+         * Prefix added before the object name when requesting the origin server. Limit: up to 512 characters.
          */
-        date: string;
+        withKeySuffix: string;
+    }
+    interface BucketMirrorBackRuleRedirectTransformReplaceKeyPrefix {
         /**
-         * Number of days to transition the latest version object in the lifecycle rule based on last modified time
+         * Object name prefix to be replaced when requesting the origin. Limit: Supports up to 512 characters.
          */
-        days: number;
+        keyPrefix: string;
         /**
-         * Storage class for historical version object transition in lifecycle rules based on last modified time. Includes STANDARD, IA, ARCHIVE*FR, INTELLIGENT*TIERING, COLD*ARCHIVE, ARCHIVE, DEEP*COLD_ARCHIVE
+         * Value of the object name prefix after replacement when requesting the origin. Limit: Supports up to 512 characters.
          */
-        storageClass: string;
+        replaceWith: string;
     }
     interface BucketNotificationNotificationRule {
         /**
@@ -23952,6 +25521,36 @@ export declare namespace tos {
          */
         value: string;
     }
+    interface BucketObjectLockConfiguration {
+        /**
+         * Enable retention policy Only Enabled is supported, which means the retention policy is enabled
+         */
+        objectLockEnabled: string;
+        /**
+         * Bucket retention policy rules
+         */
+        rule: outputs.tos.BucketObjectLockConfigurationRule;
+    }
+    interface BucketObjectLockConfigurationRule {
+        /**
+         * Default bucket retention policy
+         */
+        defaultRetention: outputs.tos.BucketObjectLockConfigurationRuleDefaultRetention;
+    }
+    interface BucketObjectLockConfigurationRuleDefaultRetention {
+        /**
+         * Object lock days Objects cannot be deleted or overwritten during the specified number of days. Measured in days
+         */
+        days: number;
+        /**
+         * Retention policy mode Only COMPLIANCE is supported, which means compliance mode. In this mode, no user can delete or overwrite locked objects during the retention period
+         */
+        mode: string;
+        /**
+         * Object lock years Objects cannot be deleted or overwritten during the specified number of years. Measured in years, with one year equal to 365 days
+         */
+        years: number;
+    }
     interface BucketRealtimeLogRealTimeLog {
         /**
          * Role name. Used to grant TOS Object Storage permission to create resources such as projects and topics in Log Service TLS and to write logs
@@ -24223,6 +25822,295 @@ export declare namespace tos {
          */
         storageClass: string;
     }
+    interface GetBucketMirrorBackRule {
+        /**
+         * Conditions that trigger the back-to-origin function.
+         */
+        condition: outputs.tos.GetBucketMirrorBackRuleCondition;
+        /**
+         * Rule ID. The unique identifier for the back-to-origin rule configured on the current bucket. You can set this yourself to distinguish between multiple rules. Restrictions:
+         * Characters supported: letters, numbers,   - and _.
+         * Maximum length: 32 characters.
+         */
+        id: string;
+        /**
+         * Back-to-origin redirect configuration.
+         */
+        redirect: outputs.tos.GetBucketMirrorBackRuleRedirect;
+    }
+    interface GetBucketMirrorBackRuleCondition {
+        /**
+         * Supports triggering origin fetch only for specified domains. The domain must be able to access the bucket; it is recommended to use a custom domain bound to the bucket. Limit: supports up to 30 domains.
+         */
+        allowHosts: string[];
+        /**
+         * Error code that triggers origin fetch. When a download request returns this error code, origin fetch is triggered. Limit: currently only supports 404.
+         */
+        httpCode: number;
+        /**
+         * Request types that trigger back-to-origin. Value description:
+         * ["GET","HEAD"]: Both GetObject and HeadObject requests can trigger back-to-origin.
+         * ["GET"]: Only GetObject requests can trigger back-to-origin.
+         * Default is ["GET"].
+         */
+        httpMethods: string[];
+        /**
+         * Object name prefix for matching origin fetch objects. Limit: supports up to 512 characters.
+         */
+        keyPrefix: string;
+        /**
+         * Object name suffix for matching origin fetch objects. Limit: supports up to 512 characters.
+         */
+        keySuffix: string;
+    }
+    interface GetBucketMirrorBackRuleRedirect {
+        /**
+         * List of rules for writing origin response headers to object metadata.
+         */
+        fetchHeaderToMetaDataRules: outputs.tos.GetBucketMirrorBackRuleRedirectFetchHeaderToMetaDataRule[];
+        /**
+         * Whether to fetch data from the configured origin after redirection. Value description: true: Fetch data from the configured origin after redirection. false: Do not fetch data from the configured origin after redirection.
+         */
+        fetchSourceOnRedirect: boolean;
+        /**
+         * Whether to include request parameters when fetching data after redirection. If not configured, inherits PassQuery settings: true: includes request parameters. false: does not include request parameters.
+         */
+        fetchSourceOnRedirectWithQuery: boolean;
+        /**
+         * If the result of mirror origin fetch is 3xx, whether to continue redirecting to the specified Location to fetch data. Value description: true: TOS will continue to request the address corresponding to Location. false: TOS will return 302.
+         */
+        followRedirect: boolean;
+        /**
+         * Specify the headers to include when mirroring back to origin.
+         */
+        mirrorHeader: outputs.tos.GetBucketMirrorBackRuleRedirectMirrorHeader;
+        /**
+         * List of origin response headers allowed to be passed through directly.
+         */
+        passHeaderFromSources: string[];
+        /**
+         * Whether to include request parameters when performing redirect or mirror back-to-origin rules. Value description:
+         * true: Include request parameters.
+         * false: Do not include request parameters.
+         */
+        passQuery: boolean;
+        /**
+         * List of origin response status codes allowed to be passed through directly.
+         */
+        passStatusCodeFromSources: number[];
+        /**
+         * Back-to-origin address configuration when the origin server is a private bucket.
+         */
+        privateSource: outputs.tos.GetBucketMirrorBackRuleRedirectPrivateSource;
+        /**
+         * Back-to-origin address configuration when the origin server is a public bucket.
+         */
+        publicSource: outputs.tos.GetBucketMirrorBackRuleRedirectPublicSource;
+        /**
+         * Specify redirect type. Value range: Mirror: Mirror origin fetch. Async: Redirect origin fetch.
+         */
+        redirectType: string;
+        /**
+         * Define transformations for the object name when requesting the origin server.
+         */
+        transform: outputs.tos.GetBucketMirrorBackRuleRedirectTransform;
+    }
+    interface GetBucketMirrorBackRuleRedirectFetchHeaderToMetaDataRule {
+        /**
+         * Suffix appended when writing object metadata.
+         */
+        metaDataSuffix: string;
+        /**
+         * Origin response header name.
+         */
+        sourceHeader: string;
+    }
+    interface GetBucketMirrorBackRuleRedirectMirrorHeader {
+        /**
+         * Whether to forward all HTTP headers to the origin. Values: true: forwards all HTTP headers to the origin. false: does not forward all HTTP headers to the origin. The following HTTP header types are not supported for forwarding: Host, Content-Length, Date, Authorization.
+         */
+        passAll: boolean;
+        /**
+         * Pass the specified headers to the origin server. Limit: up to 64.
+         */
+        passes: string[];
+        /**
+         * Prohibit forwarding specified headers to the origin. Limit: maximum 64.
+         */
+        removes: string[];
+        /**
+         * List of request headers to add or overwrite during origin fetch.
+         */
+        sets: outputs.tos.GetBucketMirrorBackRuleRedirectMirrorHeaderSet[];
+    }
+    interface GetBucketMirrorBackRuleRedirectMirrorHeaderSet {
+        /**
+         * Request header name.
+         */
+        key: string;
+        /**
+         * Request header value.
+         */
+        value: string;
+    }
+    interface GetBucketMirrorBackRuleRedirectPrivateSource {
+        /**
+         * Back-to-origin address configuration when the origin server is a private bucket.
+         */
+        sourceEndpoint: outputs.tos.GetBucketMirrorBackRuleRedirectPrivateSourceSourceEndpoint;
+    }
+    interface GetBucketMirrorBackRuleRedirectPrivateSourceSourceEndpoint {
+        /**
+         * Backup private origin node list.
+         */
+        followers: outputs.tos.GetBucketMirrorBackRuleRedirectPrivateSourceSourceEndpointFollower[];
+        /**
+         * Origin address for requests. Supports up to 5 origin fetch addresses. Required when the origin is a private bucket.
+         */
+        primaries: outputs.tos.GetBucketMirrorBackRuleRedirectPrivateSourceSourceEndpointPrimary[];
+    }
+    interface GetBucketMirrorBackRuleRedirectPrivateSourceSourceEndpointFollower {
+        /**
+         * Name of the origin fetch bucket. Required when the origin is a private bucket.
+         */
+        bucketName: string;
+        /**
+         * Private back-to-origin authentication method. Required when the origin server is a private bucket.
+         */
+        credentialProvider: outputs.tos.GetBucketMirrorBackRuleRedirectPrivateSourceSourceEndpointFollowerCredentialProvider;
+        /**
+         * Access domain name of the origin service provider, excluding bucket name, maximum length 255. Required for private buckets.
+         */
+        endpoint: string;
+    }
+    interface GetBucketMirrorBackRuleRedirectPrivateSourceSourceEndpointFollowerCredentialProvider {
+        /**
+         * Region where the origin fetch bucket is located. Required when using AK/SK authentication.
+         */
+        region: string;
+        /**
+         * Name of AssumeRole. Only when fetching from a private TOS bucket can AssumeRole be used for authentication. Role authentication and AK/SK authentication are mutually exclusive and cannot be set simultaneously.
+         */
+        role: string;
+        /**
+         * Authenticate using AK/SK.
+         */
+        staticCredential: outputs.tos.GetBucketMirrorBackRuleRedirectPrivateSourceSourceEndpointFollowerCredentialProviderStaticCredential;
+    }
+    interface GetBucketMirrorBackRuleRedirectPrivateSourceSourceEndpointFollowerCredentialProviderStaticCredential {
+        /**
+         * AccessKey ID of the origin bucket. Required when using AK/SK authentication.
+         */
+        ak: string;
+        /**
+         * SecretKey for the back-to-origin bucket. Required when using AK/SK authentication.
+         */
+        sk: string;
+        /**
+         * Encryption method used for SecretKey. Values:
+         * Empty: SecretKey is in plaintext. After receiving the SecretKey, the server will encrypt and store it.
+         * AES256: SecretKey has been encrypted using the AES256 algorithm on the server side. After receiving the SecretKey, the server will parse and encrypt it for storage.
+         * Note: When a back-to-origin rule is created for the first time, the SecretKey is encrypted with AES256. If you modify the back-to-origin rule without changing the SecretKey parameter, you must first decrypt the SecretKey and then re-encrypt it for storage. Therefore, when calling the PutBucketMirrorBack API to modify the back-to-origin rule and only changing other parameters (not the SecretKey), you can set SKEncryptType to AES256.
+         */
+        skEncryptType: string;
+        /**
+         * Origin service provider. Values: BOS: Baidu Cloud. S3: Other cloud providers using the S3 storage protocol.
+         */
+        storageVendor: string;
+    }
+    interface GetBucketMirrorBackRuleRedirectPrivateSourceSourceEndpointPrimary {
+        /**
+         * Name of the origin fetch bucket. Required when the origin is a private bucket.
+         */
+        bucketName: string;
+        /**
+         * Private back-to-origin authentication method. Required when the origin server is a private bucket.
+         */
+        credentialProvider: outputs.tos.GetBucketMirrorBackRuleRedirectPrivateSourceSourceEndpointPrimaryCredentialProvider;
+        /**
+         * Access domain name of the origin service provider, excluding bucket name, maximum length 255. Required for private buckets.
+         */
+        endpoint: string;
+    }
+    interface GetBucketMirrorBackRuleRedirectPrivateSourceSourceEndpointPrimaryCredentialProvider {
+        /**
+         * Region where the origin fetch bucket is located. Required when using AK/SK authentication.
+         */
+        region: string;
+        /**
+         * Name of AssumeRole. Only when fetching from a private TOS bucket can AssumeRole be used for authentication. Role authentication and AK/SK authentication are mutually exclusive and cannot be set simultaneously.
+         */
+        role: string;
+        /**
+         * Authenticate using AK/SK.
+         */
+        staticCredential: outputs.tos.GetBucketMirrorBackRuleRedirectPrivateSourceSourceEndpointPrimaryCredentialProviderStaticCredential;
+    }
+    interface GetBucketMirrorBackRuleRedirectPrivateSourceSourceEndpointPrimaryCredentialProviderStaticCredential {
+        /**
+         * AccessKey ID of the origin bucket. Required when using AK/SK authentication.
+         */
+        ak: string;
+        /**
+         * SecretKey for the back-to-origin bucket. Required when using AK/SK authentication.
+         */
+        sk: string;
+        /**
+         * Encryption method used for SecretKey. Values:
+         * Empty: SecretKey is in plaintext. After receiving the SecretKey, the server will encrypt and store it.
+         * AES256: SecretKey has been encrypted using the AES256 algorithm on the server side. After receiving the SecretKey, the server will parse and encrypt it for storage.
+         * Note: When a back-to-origin rule is created for the first time, the SecretKey is encrypted with AES256. If you modify the back-to-origin rule without changing the SecretKey parameter, you must first decrypt the SecretKey and then re-encrypt it for storage. Therefore, when calling the PutBucketMirrorBack API to modify the back-to-origin rule and only changing other parameters (not the SecretKey), you can set SKEncryptType to AES256.
+         */
+        skEncryptType: string;
+        /**
+         * Origin service provider. Values: BOS: Baidu Cloud. S3: Other cloud providers using the S3 storage protocol.
+         */
+        storageVendor: string;
+    }
+    interface GetBucketMirrorBackRuleRedirectPublicSource {
+        /**
+         * Whether to always use the configured origin address.
+         */
+        fixedEndpoint: boolean;
+        /**
+         * Publicly accessible origin address.
+         */
+        sourceEndpoint: outputs.tos.GetBucketMirrorBackRuleRedirectPublicSourceSourceEndpoint;
+    }
+    interface GetBucketMirrorBackRuleRedirectPublicSourceSourceEndpoint {
+        /**
+         * Origin address. Limit: Maximum length 255, supports up to 5 origin fetch addresses. When all origin fetches fail in Primary, an origin is selected from this configuration.
+         */
+        followers: string[];
+        /**
+         * Origin address. Limit: Maximum length 255, supports up to 5 origin fetch addresses.
+         */
+        primaries: string[];
+    }
+    interface GetBucketMirrorBackRuleRedirectTransform {
+        /**
+         * Object name prefix to be replaced when requesting the origin.
+         */
+        replaceKeyPrefix: outputs.tos.GetBucketMirrorBackRuleRedirectTransformReplaceKeyPrefix;
+        /**
+         * Prefix added before the object name when requesting the origin server. Limit: up to 512 characters.
+         */
+        withKeyPrefix: string;
+        /**
+         * Prefix added before the object name when requesting the origin server. Limit: up to 512 characters.
+         */
+        withKeySuffix: string;
+    }
+    interface GetBucketMirrorBackRuleRedirectTransformReplaceKeyPrefix {
+        /**
+         * Object name prefix to be replaced when requesting the origin. Limit: Supports up to 512 characters.
+         */
+        keyPrefix: string;
+        /**
+         * Value of the object name prefix after replacement when requesting the origin. Limit: Supports up to 512 characters.
+         */
+        replaceWith: string;
+    }
     interface GetBucketNotificationNotificationRule {
         /**
          * Event notification delivery targets. Must include at least one target and supports up to five different targets.
@@ -24323,6 +26211,36 @@ export declare namespace tos {
          */
         value: string;
     }
+    interface GetBucketObjectLockConfiguration {
+        /**
+         * Enable retention policy Only Enabled is supported, which means the retention policy is enabled
+         */
+        objectLockEnabled: string;
+        /**
+         * Bucket retention policy rules
+         */
+        rule: outputs.tos.GetBucketObjectLockConfigurationRule;
+    }
+    interface GetBucketObjectLockConfigurationRule {
+        /**
+         * Default bucket retention policy
+         */
+        defaultRetention: outputs.tos.GetBucketObjectLockConfigurationRuleDefaultRetention;
+    }
+    interface GetBucketObjectLockConfigurationRuleDefaultRetention {
+        /**
+         * Object lock days Objects cannot be deleted or overwritten during the specified number of days. Measured in days
+         */
+        days: number;
+        /**
+         * Retention policy mode Only COMPLIANCE is supported, which means compliance mode. In this mode, no user can delete or overwrite locked objects during the retention period
+         */
+        mode: string;
+        /**
+         * Object lock years Objects cannot be deleted or overwritten during the specified number of years. Measured in years, with one year equal to 365 days
+         */
+        years: number;
+    }
     interface GetBucketRealtimeLogRealTimeLog {
         /**
          * Role name. Used to grant TOS Object Storage permission to create resources such as projects and topics in Log Service TLS and to write logs
@@ -24353,6 +26271,26 @@ export declare namespace tos {
     }
 }
 export declare namespace transitrouter {
+    interface DirectConnectGatewayAttachmentTag {
+        /**
+         * Tag key
+         */
+        key: string;
+        /**
+         * Tag value
+         */
+        value: string;
+    }
+    interface GetDirectConnectGatewayAttachmentTag {
+        /**
+         * Tag key
+         */
+        key: string;
+        /**
+         * Tag value
+         */
+        value: string;
+    }
     interface GetPeerAttachmentTag {
         /**
          * Tag key for cross-region connection user tags. Length must be between 1 and 128 characters. Case-sensitive; cannot start with any case combination of sys:. Cannot start or end with a space character. Allowed characters include letters, numbers, space character, underscore (_), period (.), colon (:), slash (/), equals sign (=), plus sign (+), minus sign (-), and @. Note: Tag keys for the same resource must be unique. If this parameter is not provided or no value is specified, the default is empty.
@@ -24451,6 +26389,38 @@ export declare namespace transitrouter {
          */
         value: string;
     }
+    interface GetTransitRouterBandwidthPackageAllocation {
+        /**
+         * Time when the bandwidth package was associated with the cross-region connection.
+         */
+        allocateTime: string;
+        /**
+         * Bandwidth peak of the cross-region connection, in Mbps.
+         */
+        bandwidth: number;
+        /**
+         * Region ID of the local transit router instance in the cross-region connection.
+         */
+        localRegionId: string;
+        /**
+         * Region ID of the peer transit router instance in the cross-region connection.
+         */
+        peerRegionId: string;
+        /**
+         * ID of the cross-region connection.
+         */
+        transitRouterPeerAttachmentId: string;
+    }
+    interface GetTransitRouterBandwidthPackageTag {
+        /**
+         * Tag key of the tag.
+         */
+        key: string;
+        /**
+         * Tag value
+         */
+        value: string;
+    }
     interface GetTransitRouterRouteTableTag {
         /**
          * Tag key
@@ -24600,6 +26570,38 @@ export declare namespace transitrouter {
          */
         value: string;
     }
+    interface TransitRouterBandwidthPackageAllocation {
+        /**
+         * Time when the bandwidth package was associated with the cross-region connection.
+         */
+        allocateTime: string;
+        /**
+         * Bandwidth peak of the cross-region connection, in Mbps.
+         */
+        bandwidth: number;
+        /**
+         * Region ID of the local transit router instance in the cross-region connection.
+         */
+        localRegionId: string;
+        /**
+         * Region ID of the peer transit router instance in the cross-region connection.
+         */
+        peerRegionId: string;
+        /**
+         * ID of the cross-region connection.
+         */
+        transitRouterPeerAttachmentId: string;
+    }
+    interface TransitRouterBandwidthPackageTag {
+        /**
+         * Tag key of the tag.
+         */
+        key: string;
+        /**
+         * Tag value
+         */
+        value: string;
+    }
     interface TransitRouterRouteTableTag {
         /**
          * Tag key