@emqx/shared-ui-i18n 0.0.40 → 0.0.41

package/dist/index.js

@@ -1468,7 +1468,7 @@ HGETALL mqtt_acl:\${username}`
     strategy: "生产者密钥分派策略，默认为 `roundrobin`，支持占位符。"
   },
   tdengine: {
-    server: "将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/>主机名具有以下形式：`Host[:Port]`。<br/>如果未指定 `[:Port]`，则使用 TDengine 默认端口 6041。",
+    server: "将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/>主机名具有以下形式：`[http[s]://]Host[:Port]`。<br/>如果未指定 `[:Port]`，则使用 TDengine 默认端口 6041。",
     sql: "SQL 模板",
     token: "连接到 TDengine Cloud 时使用的令牌。<br/>如果提供了令牌，它将覆盖用户名和密码的认证方式。"
   },
@@ -1893,7 +1893,7 @@ For bridges only have ingress direction data flow, it can be set to 0 otherwise
     strategy: "Producer key dispatch strategy, the default is `roundrobin`, also supports placeholders."
   },
   tdengine: {
-    server: "The IPv4 or IPv6 address or the hostname to connect to.<br/>A host entry has the following form: `Host[:Port]`.<br/>The TDengine default port 6041 is used if `[:Port]` is not specified.",
+    server: "The IPv4 or IPv6 address or the hostname to connect to.<br/>A host entry has the following form: `[http[s]://]Host[:Port]`.<br/>The TDengine default port 6041 is used if `[:Port]` is not specified.",
     sql: "SQL Template",
     token: "The token used when connecting to TDengine Cloud. <br/>If this value is provided, it will override the authentication method of Username and Password."
   },

package/dist/index.umd.cjs

@@ -81,7 +81,7 @@ HSET mqtt_acl:emqx_u 't/#' subscribe
 # sample cmd
 HGETALL mqtt_acl:\${username}`}},n={async:"Async",sync:"Sync",get:"GET",post:"POST",delete:"DELETE",put:"PUT",producer:"Producer",consumer:"Consumer",ns:"nanosecond",us:"microsecond",ms:"millisecond",s:"second",none:"None",base64:"Base64",json:"JSON",authentication_auth_gssapi_kerberos:"Kerberos",authentication_auth_username_password:"Basic auth",authentication_auth_basic:"Basic auth",authentication_auth_token:"Token",authentication_none:"None",parameters_connector_single:"single",parameters_connector_rs:"rs",parameters_connector_sharded:"sharded",parameters_redis_single_connector:"single",parameters_redis_sentinel_connector:"rs",parameters_redis_cluster_connector:"sharded",parameters_connector_influxdb_api_v_1:"v1",parameters_connector_influxdb_api_v_2:"v2",parameters_action_update:"Update",parameters_action_delete:"Delete",parameters_action_create:"Create",parameters_s_3_direct_upload_parameters:"Direct Upload",parameters_s_3_aggregated_upload_parameters:"Aggregated Upload",parameters_direct_parameters:"Direct Upload",parameters_aggreg_parameters:"Aggregated Upload",all_partitions:"All Partitions",plain:"Plain",scram_sha_256:"SHA256",scram_sha_512:"SHA512",m:"minute",h:"hour",d:"day",no_compression:"No compression",restapi:"REST API",thrift:"Thrift Protocol",protocol_v1:"v1",protocol_v2:"v2",protocol_v3:"v3",influxdb_v1:"InfluxDB Line Protocol",aggregated:"Aggregated Upload",parameters_proxy_none:"None",parameters_proxy_proxy_config:"Enable Proxy",proxy_none:"None",proxy_proxy_config:"Enable Proxy",vhost:"Virtual Hosted",path:"Path",v3:"v3(3.1)",v4:"v4(3.1.1)",v5:"v5(5.0)",timeseries:"TimeSeries"},c={async:"异步",sync:"同步",get:"GET",post:"POST",delete:"DELETE",put:"PUT",producer:"生产者",consumer:"消费者",ns:"纳秒",us:"微秒",ms:"毫秒",s:"秒",none:"None",base64:"Base64",json:"JSON",authentication_auth_gssapi_kerberos:"Kerberos",authentication_auth_username_password:"基础认证",authentication_auth_basic:"基础认证",authentication_auth_token:"Token",authentication_none:"无",parameters_connector_single:"single",parameters_connector_rs:"rs",parameters_connector_sharded:"sharded",parameters_redis_single_connector:"single",parameters_redis_sentinel_connector:"sentinel",parameters_redis_cluster_connector:"cluster",parameters_connector_influxdb_api_v_1:"v1",parameters_connector_influxdb_api_v_2:"v2",parameters_action_update:"更新",parameters_action_delete:"删除",parameters_action_create:"创建",parameters_s_3_direct_upload_parameters:"直接上传",parameters_s_3_aggregated_upload_parameters:"聚合上传",parameters_direct_parameters:"直接上传",parameters_aggreg_parameters:"聚合上传",all_partitions:"所有分区",plain:"Plain",scram_sha_256:"SHA256",scram_sha_512:"SHA512",m:"分钟",h:"小时",d:"天",no_compression:"不压缩",restapi:"REST API",thrift:"Thrift 协议",protocol_v1:"v1",protocol_v2:"v2",protocol_v3:"v3",influxdb_v1:"InfluxDB 行协议",aggregated:"聚合上传",parameters_proxy_none:"无",parameters_proxy_proxy_config:"开启代理",proxy_none:"无",proxy_proxy_config:"开启代理",vhost:"虚拟托管",path:"路径",v3:"v3(3.1)",v4:"v4(3.1.1)",v5:"v5(5.0)",timeseries:"时序"},l={common:{auto_restart_interval:"资源断开以后，自动重连的时间间隔。",batch_size:"最大批量请求大小。如果设为 1，则无批处理。",batch_time:"在较低消息率情况下尝试累积批量输出时的最大等待间隔，以提高资源的利用率。",enable_queue:"启用磁盘缓存队列（仅对 egress 方向桥接有用）。",health_check_interval:"健康检查间隔。",inflight_window:"请求飞行队列窗口大小。当请求模式为异步时，如果需要严格保证来自同一 MQTT 客户端的消息有序，则必须将此值设为 1。",query_mode:"请求模式。可选 '同步/异步'，默认为'异步'模式。",request_ttl:"从请求进入缓冲区开始计时，如果请求在规定的时间内仍停留在缓冲区内或者已发送但未能及时收到响应或确认，该请求将被视为过期。",start_timeout:"在回复资源创建请求前等待资源进入健康状态的时间。",worker_pool_size:"缓存队列 worker 数量。仅对 egress 类型的桥接有意义。当桥接仅有 ingress 方向时，可设置为 0，否则必须大于 0。",max_buffer_bytes:"每个缓存 worker 允许使用的最大字节数。",password:"相关联的外部数据库中，用于认证或识别的密码。",pool_size:"桥接远端服务时使用的连接池大小。",prepare_statement:"SQL 预处理语句列表。",ssl:"启用 SSL 连接。",username:"相关联的外部数据库中，用于认证或识别的用户名。",database:"数据库名字。",tcp_keepalive:"启用连接器的 TCP keepalive。<br/>该值是三个逗号分隔的数字，格式为`空闲时间,间隔时间,尝试次数`<br/>- 空闲时间：连接在服务器开始发送 keep-alive 探测之前需要空闲的秒数（Linux 默认为 7200）。<br/>- 间隔时间：TCP keep-alive 探测之间的秒数（Linux 默认为 75）。<br/>- 尝试次数：在从另一端获得响应之前发送的 TCP keep-alive 探测的最大次数（Linux 默认为 9）。<br/>例如，\"240,30,5\" 表示：在连接空闲 240 秒后发送 TCP keepalive 探测，并在每隔 30 秒发送一次探测，如果连续 5 次没有响应，则应该关闭连接。<br/>默认值：'none'",sndbuf:"TCP socket 的发送缓存调优。默认值是针对高吞吐量的一个推荐值。",recbuf:"TCP socket 的收包缓存调优。默认值是针对高吞吐量的一个推荐值。",nodelay:"设置 `true` 让系统内核立即发送。否则当需要发送的内容很少时，可能会有一定延迟（默认 40 毫秒）。",pool_type:"连接池的类型。可以是`random`、`hash`之一。",max_retries:"请求出错时的最大重试次数。",memory_overload_protection:`在缓冲区模式设置为 <code>memory</code> 时适用
 在内存压力较大时，EMQX 将删除旧的缓冲消息。注意：此配置仅适用于 Linux。`,disable_prepared_statements:"在连接中禁用预处理语句。某些端点（如事务模式下的 PGBouncer 或 Supabase）不支持会话功能（如预处理语句）。对于此类连接，应启用此选项。",health_check_topic:"专用于精确检查健康状态的主题名称。",max_records:"每个聚合对象允许的记录（事件）数量。每次聚合上传包含的事件数量不会超过此数值，但可能会更少。<br/>如果事件速率足够高，在同一时间间隔内显然可能会有多个聚合上传。这些上传将具有不同但连续的序列号，这些序列号将是 S3 对象键的一部分。",max_linger_time:"每个分区生产者，等待收集消息以形成批次的最长时间。<br/>默认值 <code>0</code> 表示不等待。对于非内存缓冲模式，建议至少配置 <code>5ms</code> 以减少 I/O 操作。",max_linger_bytes:"每个分区生产者，等待收集消息以形成批次的最大字节数。",undefined_vars_as_null:"在写入数据库时，将未定义的变量视为 NULL。<br/>当启用此选项时，如果在模板中使用未定义的变量（例如 `${'{'}var{'}'}`），它们将被替换为 `NULL`，而不是字符串 `undefined`。如果此选项未启用（默认为关闭），可能会插入字符串 `undefined`。<br/>如果可能，此选项应始终设置为 `true`；默认值 `false` 仅用于确保向后兼容性。",max_inactive:"HTTP 驱动在无任何活动时，尝试重连前的最大等待时间。"},mqtt:{bridge_mode:"该设置仅适用于 MQTT 协议版本低于 5.0 的情况，且远程 MQTT 服务必须支持该功能。开启后，远端服务器将识别当前连接为一个桥接，消息回环检测更高效，收到的保留消息标志位会透传给本地。",clean_start:"当重新连接到远程服务，该 MQTT 服务作为入口桥接时，是否启动一个干净的会话。",retry_interval:"在未收到 ACK 的情况下，QoS1/QoS2 消息的重试间隔。",clientid_prefix:"连接器随机生成客户端 ID 时所使用的前缀。",max_inflight:"消息发布时，可以同时等待确认的未确认消息数量，用以提高消息传递效率和吞吐量。",topic:"消息发布主题，支持使用 ${'{'}field{'}'} 语法提取变量动态拼接主题。",source_topic:"消息订阅主题，支持使用 + 和 # 通配符。当 EMQX 运行在集群模式下或连接器配置了连接池时，为了避免消息重复，必须使用共享订阅。",payload:"例如：${'{'}payload{'}'}, ${'{'}clientid{'}'}, ${'{'}topic{'}'}, ${'{'}username{'}'} 等。请根据使用动作的业务需求来选择字段，置空则原样转发消息。支持使用 ${'{'}field{'}'} 语法读取数据。",static_clientids:"配置 EMQX 节点与静态客户端 ID 的对应关系。当配置了映射关系后，只有在映射中指定的 EMQX 节点才会创建对应的 MQTT 客户端连接。",node:"EMQX 的节点名称，例如：<code>emqx{'@'}10.0.0.1</code>",ids:"指定给该节点的静态客户端 ID 列表"},http:{url:"HTTP 连接器的 URL。<br/>路径中支持占位符，但在主机或端口部分中不能使用占位符。<br/>例如，`http://localhost:9901/${'{'}topic{'}'}` 是允许的，但是 `http://${'{'}host{'}'}:9901/message` 或 `http://localhost:${'{'}port{'}'}/message `不允许。",body:"例如：${'{'}payload{'}'}, ${'{'}clientid{'}'}, ${'{'}topic{'}'}, ${'{'}username{'}'} 等。请根据使用动作的业务需求来选择字段，置空则原样转发消息。",path:"此操作的 URL 路径。<br/>此路径将附加到连接器的 <code>url</code> 配置中，以形成完整的 URL 地址。此选项中允许使用带有变量的模板。 例如，<code>/room/{'{'}$room_no{'}'}</code>"},cassandra:{keyspace:"要连接到的 Keyspace 名称。",servers:"将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/>主机名具有以下形式：`Host[:Port][,Host2:Port]`。<br/>如果未指定 `[:Port]`，则使用 Cassandra 默认端口 9042。",cql:"CQL 模板"},clickhouse:{batch_value_separator:"默认为逗号 ','，适用于 VALUES 格式。您也可以使用其他分隔符， 请参考 [INSERT INTO 语句](https://clickhouse.com/docs/zh/sql-reference/statements/insert-into)。",connect_timeout:"连接 Clickhouse 服务器的超时时间。",url:"你想连接到的 Clickhouse 服务器的 HTTP URL（例如 http://myhostname:8123）。",sql:"可以使用 ${'{'}field{'}'} 占位符来引用消息与客户端上下文中的变量，请确保对应字段存在且数据格式符合预期。此处不支持 [SQL 预处理](https://docs.emqx.com/zh/enterprise/v5.0/data-integration/data-bridges.html#sql-预处理)。"},dynamo:{template:`模板，默认值为空。当此值为空时，整个消息将存储在数据库中。<br/>模板可以是任何带有占位符的有效 JSON，并确保表中所有的键都在这里，例如：<br/>  \`{'{'}"id" : "\${'{'}id{'}'}", "clientid" : "\${'{'}clientid{'}'}", "data" : "\${'{'}payload.data{'}'}"{'}'}\``,url:"DynamoDB 的地址。",table:"DynamoDB 的表。",aws_access_key_id:"DynamoDB 的访问 ID。",aws_secret_access_key:"DynamoDB 的访问密钥。",region:"AWS DynamoDB 所在的区域"},gcp_pubsub_producer:{pipelining:"正整数，设置最大可发送的异步 HTTP 请求数量。当设置为 1 时，表示每次发送完成 HTTP 请求后都需要等待服务器返回，再继续发送下一个请求。",connect_timeout:"连接 GCP 服务器的超时时间。",service_account_json:"包含将与 PubSub 一起使用的 GCP 服务账户凭证的 JSON。<br/>当创建 GCP 服务账户时（如 https://developers.google.com/identity/protocols/oauth2/service-account#creatinganaccount ），可以选择下载 JSON 形式的凭证，然后在该配置项中使用。",pubsub_topic:"要发布消息的 GCP PubSub 主题。",payload_template:"用于格式化外发信息的模板。 如果未定义，将以 JSON 格式发送所有可用的上下文。",attributes_template:"用于格式化消息属性的模板。未定义的值将被渲染为空字符串。空键将从属性映射中删除。",ordering_key_template:"用于格式化消息排序键的模板。未定义的值将被渲染为空字符串。如果此值为空，则不会将其添加到消息中。"},gcp_pubsub_consumer:{topic:"要消费的 GCP PubSub 主题。",pipelining:"正整数，设置最大可发送的异步 HTTP 请求数量。当设置为 1 时，表示每次发送完成 HTTP 请求后都需要等待服务器返回，再继续发送下一个请求。",service_account_json:"包含将与 PubSub 一起使用的 GCP 服务账户凭证的 JSON。<br/>当创建 GCP 服务账户时（如 https://developers.google.com/identity/protocols/oauth2/service-account#creatinganaccount ），可以选择下载 JSON 形式的凭证，然后在该配置项中使用。",pull_max_messages:`从 GCP PubSub 中在一个拉取请求里检索的最大消息数。
-实际数量可能小于指定的值。`,connect_timeout:"连接 GCP 服务器的超时时间。"},hstreamdb:{url:"HStreamDB 服务器的 URL。使用 gRPC HTTP 服务器地址。",partition_key:"HStreamDB 分区键。支持占位符。",grpc_flush_timeout:"刷新 gRPC 调用到 HStreamDB 服务器的时间间隔。",aggregation_pool_size:"记录聚合池的大小。增大聚合池可提升并行处理能力，但可能会因批处理变小而影响效率。",max_batches:"刷新队列中最大未确认批次数。",writer_pool_size:"写入池大小。扩大池规模可增加并行化和同时写入操作，可能提升吞吐量。但需权衡内存消耗和资源竞争。",batch_interval:"两个连续（批量）请求之间的最大间隔。",record_template:"将被转发到 HStreamDB 的 HStream record 模板。支持占位符。<br/>注意：当使用 `raw record` 模板（意味着数据不是有效的 JSON）时，应该在 HStream 中使用 `read` 或 `subscription` 来获取数据。",parameters_batch_size:"单个请求中可发送的插入数据子句的最大数量。"},influxdb:{server:"将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/><br/>主机名具有以下形式：`Host[:Port]`。<br/><br/>如果未指定 `[:Port]`，则使用 InfluxDB 默认端口 8086。",token:"InfluxDB token。",org:"InfluxDB 组织名称。",bucket:"InfluxDB bucket 名称。",write_syntax:"使用 InfluxDB API Line Protocol 写入 InfluxDB 的数据，支持占位符，参考 [InfluxDB 2.3 Line Protocol](https://docs.influxdata.com/influxdb/v2.3/reference/syntax/line-protocol/) 及 [InfluxDB 1.8 Line Protocol](https://docs.influxdata.com/influxdb/v1.8/write_protocols/line_protocol_tutorial/) <br/>TLDR: <br/>```<measurement>[,<tag_key>=<tag_value>[,<tag_key>=<tag_value>]] <field_key>=<field_value>[,<field_key>=<field_value>] [<timestamp>]```<br/>注意，整形数值占位符后需要添加一个字符 `i` 类型标识。例如 `${'{'}payload.int_value{'}'}i`",precision:"InfluxDB 时间精度。"},datalayers:{write_syntax:"Datalayers 采用与 InfluxDB v1 完全兼容的行协议，为用户提供了熟悉且高效的数据写入方式。虽然兼容InfluxDB v1 的语法，但 Datalayers 在底层实现上有其独特之处，以优化性能和适应其特定的存储结构。参考 [InfluxDB Line Protocol](https://docs.datalayers.cn/datalayers/latest/development-guide/writing-with-influxdb-line-protocol.html)",precision:"Datalayers 时间精度。"},confluent_producer:{connect_timeout:"建立 TCP 连接时的最大等待时长（若启用认证，这个等待时长也包含完成认证所需时间）。",bootstrap_hosts:"用逗号分隔的 <code>host[:port]</code> 主机列表。默认端口号为 9092。",min_metadata_refresh_interval:"刷新 Kafka broker 和 Kafka 主题元数据的最短时间间隔。设置太小可能会增加 Kafka 压力。",metadata_request_timeout:"刷新元数据时最大等待时长。",topic:"Kafka 主题名称",kafka_headers:`请提供用作 Kafka Headers 的占位符<br/>例如：<code>\${'{'}pub_props{'}'}</code><br/>注意占位符的值必须是一个对象：<br/>\`{'{'}"foo": "bar"{'}'}\``,kafka_header_value_encode_mode:"Kafka Headers 的值编码类型：<br/>- `NONE`：仅将二进制值添加到 Kafka Headers；<br/>- `JSON`：仅将 JSON 值添加到 Kafka Headers，并在发送之前将其编码为 JSON 字符串。",kafka_ext_headers:"请提供更多的键值对，用于 Kafka Headers。<br/>这里的键值对将与 `kafka_headers` 字段的值合并后发送到 Kafka。",key:"生成 Kafka 消息键的模版。如果模版生成后为空值，则会使用 Kafka 的 <code>NULL</code> ，而非空字符串。",value:"生成 Kafka 消息的值的模版。如果模版生成后为空值，则会使用 Kafka 的 <code>NULL</code>，而非空字符串。",partition_strategy:"设置消息发布时应该如何选择 Kafka 分区。<br/><code>random</code>: 为每个消息随机选择一个分区。<br/><code>key_dispatch</code>：对 Kafka 消息键进行哈希，以得到一个分区号。",max_batch_bytes:"最大消息批量字节数。大多数 Kafka 环境的默认最低值是 1 MB，EMQX 的默认值比 1 MB 更小是因为需要补偿 Kafka 消息编码所需要的额外字节（尤其是当每条消息都很小的情况下）。当单个消息的大小超过该限制时，它仍然会被发送，（相当于该批量中只有单个消息）。",required_acks:"设置 Kafka leader 在返回给 EMQX 确认之前需要等待多少个 follower 的确认。<br/><code>all_isr</code>: 需要所有的在线复制者都确认。<br/><code>leader_only</code>: 仅需要分区 leader 确认。<br/><code>none</code>: 无需 Kafka 回复任何确认。",partition_count_refresh_interval:"配置 Kafka 刷新分区数量的时间间隔。<br/>EMQX 发现 Kafka 分区数量增加后，会开始按 <code>partition_strategy</code> 配置，把消息发送到新的分区中。",max_inflight:"设置 Kafka 生产者（每个分区一个）在收到 Kafka 的确认前最多发送多少个请求（批量）。调大这个值通常可以增加吞吐量，但是，当该值设置大于 1 时存在消息乱序的风险。",sync_query_timeout:"同步查询的超时时间。仅当请求模式配置为'同步'时才使用该配置。",mode:"消息缓存模式。<br/><code>memory</code>: 所有的消息都缓存在内存里。如果 EMQX 服务重启，缓存的消息会丢失。<br/><code>disk</code>: 缓存到磁盘上。EMQX 重启后会继续发送重启前未发送完成的消息。<br/><code>hybrid</code>: 先将消息缓存在内存中，当内存中的消息堆积超过一定限制（配置项 <code>segment_bytes</code> 描述了该限制）后，后续的消息会缓存到磁盘上。与 <code>memory</code> 模式一样，如果 EMQX 服务重启，缓存的消息会丢失。",per_partition_limit:"为每个 Kafka 分区设置的最大缓存字节数。当超过这个上限之后，老的消息会被丢弃，为新的消息腾出空间。",segment_bytes:"当缓存模式是 <code>disk</code> 或 <code>hybrid</code> 时适用。该配置用于指定缓存到磁盘上的文件的大小。",compression:"压缩方法。",partitions_limit:"限制生产者能够发送消息的最大分区数量。"},kafka_producer:{bootstrap_hosts:"用逗号分隔的 <code>host[:port]</code> 主机列表。默认端口号为 9092。",authentication:"认证参数。",connect_timeout:"建立 TCP 连接时的最大等待时长（若启用认证，这个等待时长也包含完成认证所需时间）。",min_metadata_refresh_interval:"刷新 Kafka broker 和 Kafka 主题元数据的最短时间间隔。设置太小可能会增加 Kafka 压力。",metadata_request_timeout:"刷新元数据时最大等待时长。",topic:"Kafka 主题名称",kafka_headers:`请提供用作 Kafka Headers 的占位符<br/>例如：<code>\${'{'}pub_props{'}'}</code><br/>注意占位符的值必须是一个对象：<br/>\`{'{'}"foo": "bar"{'}'}\``,kafka_header_value_encode_mode:"Kafka Headers 的值编码类型：<br/>- `NONE`：仅将二进制值添加到 Kafka Headers；<br/>- `JSON`：仅将 JSON 值添加到 Kafka Headers，并在发送之前将其编码为 JSON 字符串。",kafka_ext_headers:"请提供更多的键值对，用于 Kafka Headers。<br/>这里的键值对将与 `kafka_headers` 字段的值合并后发送到 Kafka。",key:"生成 Kafka 消息键的模版。如果模版生成后为空值，则会使用 Kafka 的 <code>NULL</code> ，而非空字符串。",value:"生成 Kafka 消息的值的模版。如果模版生成后为空值，则会使用 Kafka 的 <code>NULL</code>，而非空字符串。",kafka_message_timestamp:"生成 Kafka 消息时间戳的模版。该时间必需是一个整型数值（可以是字符串格式）例如 <code>1661326462115</code> 或 <code>'1661326462115'</code>。当所需的输入字段不存在，或不是一个整型时，则会使用当前系统时间。",compression:"压缩方法。",partition_strategy:"设置消息发布时应该如何选择 Kafka 分区。<br/><code>random</code>: 为每个消息随机选择一个分区。<br/><code>key_dispatch</code>：对 Kafka 消息键进行哈希，以得到一个分区号。",max_batch_bytes:"最大消息批量字节数。大多数 Kafka 环境的默认最低值是 1 MB，EMQX 的默认值比 1 MB 更小是因为需要补偿 Kafka 消息编码所需要的额外字节（尤其是当每条消息都很小的情况下）。当单个消息的大小超过该限制时，它仍然会被发送，（相当于该批量中只有单个消息）。",required_acks:"设置 Kafka leader 在返回给 EMQX 确认之前需要等待多少个 follower 的确认。<br/><code>all_isr</code>: 需要所有的在线复制者都确认。<br/><code>leader_only</code>: 仅需要分区 leader 确认。<br/><code>none</code>: 无需 Kafka 回复任何确认。",partition_count_refresh_interval:"配置 Kafka 刷新分区数量的时间间隔。<br/>EMQX 发现 Kafka 分区数量增加后，会开始按 <code>partition_strategy</code> 配置，把消息发送到新的分区中。",max_inflight:"设置 Kafka 生产者（每个分区一个）在收到 Kafka 的确认前最多发送多少个请求（批量）。调大这个值通常可以增加吞吐量，但是，当该值设置大于 1 时存在消息乱序的风险。",sync_query_timeout:"同步查询的超时时间。仅当请求模式配置为'同步'时才使用该配置。",mode:"消息缓存模式。<br/><code>memory</code>: 所有的消息都缓存在内存里。如果 EMQX 服务重启，缓存的消息会丢失。<br/><code>disk</code>: 缓存到磁盘上。EMQX 重启后会继续发送重启前未发送完成的消息。<br/><code>hybrid</code>: 先将消息缓存在内存中，当内存中的消息堆积超过一定限制（配置项 <code>segment_bytes</code> 描述了该限制）后，后续的消息会缓存到磁盘上。与 <code>memory</code> 模式一样，如果 EMQX 服务重启，缓存的消息会丢失。",per_partition_limit:"为每个 Kafka 分区设置的最大缓存字节数。当超过这个上限之后，老的消息会被丢弃，为新的消息腾出空间。",segment_bytes:"当缓存模式是 <code>disk</code> 或 <code>hybrid</code> 时适用。该配置用于指定缓存到磁盘上的文件的大小。",kafka_ext_header_key:"Kafka Headers 的键。支持使用 <code>${'{'}var{'}'}</code> 格式的占位符。",mechanism:"SASL 认证方法名称。",kerberos_principal:"SASL GSSAPI 认证方法的 Kerberos principal，例如 <code>client_name{'@'}MY.KERBEROS.REALM.MYDOMAIN.COM</code>注意：这里使用的 realm 需要配置在 EMQX 服务器的 /etc/krb5.conf 中",kerberos_keytab_file:"SASL GSSAPI 认证方法的 Kerberos keytab 文件。注意：该文件需要上传到 EMQX 服务器中，且运行 EMQX 服务的系统账户需要有读取权限。",kafka_ext_header_value:"Kafka Headers 的值。支持使用 <code>${'{'}var{'}'}</code> 格式的占位符。",partitions_limit:"限制生产者能够发送消息的最大分区数量。"},kafka_consumer:{bootstrap_hosts:"用逗号分隔的 <code>host[:port]</code> 主机列表。默认端口号为 9092。",key_encoding_mode:"通过 MQTT 转发之前，如何处理 Kafka 消息的 Key。<code>none</code> 使用 Kafka 消息中的 Key 原始值，不进行编码。  注意：在这种情况下，Key 必须是一个有效的 UTF-8 字符串。<br/><code>base64</code> 对收到的密钥或值使用 base-64 编码。",value_encoding_mode:"通过 MQTT 转发之前，如何处理 Kafka 消息的 Value。<code>none</code> 使用 Kafka 消息中的 Value 原始值，不进行编码。  注意：在这种情况下，Value 必须是一个有效的 UTF-8 字符串。<br/><code>base64</code> 对收到的 Value 使用 base-64 编码。",offset_reset_policy:"如不存在偏移量历史记录或历史记录失效，消费者应使用哪个偏移量开始消费。",min_metadata_refresh_interval:"刷新 Kafka broker 和 Kafka 主题元数据的最短时间间隔。设置太小可能会增加 Kafka 压力。",metadata_request_timeout:"刷新元数据时最大等待时长。",connect_timeout:"建立 TCP 连接时的最大等待时长（若启用认证，这个等待时长也包含完成认证所需时间）。",max_batch_bytes:"设置每次从 Kafka 拉取数据的字节数。<br/>消费者按批次获取消息，如果获取的第一个非空分区中的第一个记录批次大小大于这个值，该记录批次仍会被返回，以确保消费者能够继续处理。因此，这并不是一个绝对的最大值限制。如果需要实现最小延迟，可将该值设为 `1`",offset_commit_interval_seconds:"指定 Kafka 消费组偏移量提交的时间间隔。",topic:"Kafka 主题名称",group_id:"用于此 Source 的消费者组 ID。如果未指定，系统将自动生成一个基于 Source 名称的 ID。",max_wait_time:"等待 Kafka broker 发送响应对象的最大时间。"},mongodb:{collection:"数据将被存储到的集合",payload_template:"用于格式化写入 MongoDB 的消息模板。 如果未定义，规则引擎会使用 JSON 格式序列化所有的可见输入，例如 clientid, topic, payload 等。",auth_source:"与用户证书关联的数据库名称。",use_legacy_protocol:"是否使用 MongoDB 的旧协议与数据库通信。默认情况下，系统会尝试自动确定是否支持新协议。",srv_record:"使用 DNS SRV 记录。",max_overflow:"当连接池中所有线程都被占用时，可以创建的最大附加工作线程数。这有助于通过允许更多并发连接到 MongoDB 服务器来管理暂时的工作负载峰值。",overflow_ttl:"当池内工人太多时，等待多久清除多余工人。",overflow_check_period:'检查是否有超过配置的工人的周期（"溢出"）。',local_threshold:"在多个合适的 MongoDB 实例中进行选择的延迟窗口的大小。",connect_timeout:"超时重连的等待时间。",socket_timeout:"在尝试超时之前，在套接字上尝试发送或接收的持续时间。",server_selection_timeout:"指定在抛出异常之前为服务器选择阻断多长时间。",wait_queue_timeout:"工作者等待连接可用的最长时间。",heartbeat_frequency:"控制驱动程序何时检查 MongoDB 部署的状态。指定检查的间隔时间，从上一次检查结束到下一次检查开始计算。如果连接数增加（例如，如果你增加池子的大小，就会发生这种情况），你可能也需要增加这个周期，以避免在 MongoDB 日志文件中创建太多的日志条目。",min_heartbeat_frequency:"心跳间的最小间隙",server:"将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/>主机名具有以下形式：`Host[:Port]`。<br/>如果未指定 `[:Port]`，则使用 MongoDB 默认端口 27017。",w_mode:"写模式。",servers:"集群将要连接的节点列表。 节点之间用逗号分隔，如：`Node[,Node].`<br/>每个节点的配置为：将要连接的 IPv4 或 IPv6 地址或主机名。<br/>主机名具有以下形式：`Host[:Port]`。<br/>如果未指定 `[:Port]`，则使用 MongoDB 默认端口 27017。",replica_set_name:"副本集的名称。",r_mode:"读模式。"},mysql:{server:"将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/>主机名具有以下形式：`Host[:Port]`。<br/>如果未指定 `[:Port]`，则使用 MySQL 默认端口 3306。",sql:"SQL 模板"},pgsql:{server:"将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/>主机名具有以下形式：`Host[:Port]`。<br/>如果未指定 `[:Port]`，则使用默认端口 5432。",sql:"SQL 模板"},redis:{server:"将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/>主机名具有以下形式：`Host[:Port]`。<br/>如果未指定 `[:Port]`，则使用 Redis 默认端口 6379。",servers:"集群将要连接的节点列表。 节点之间用逗号分隔，如：`Node[,Node].`<br/>每个节点的配置为：将要连接的 IPv4 或 IPv6 地址或主机名。<br/>主机名具有以下形式：`Host[:Port]`。<br/>如果未指定 `[:Port]`，则使用 Redis 默认端口 6379。",sentinel:"哨兵模式。当 Redis 服务运行在哨兵模式下，该配置必须设置为 'sentinel'。",command_template:"用于推送数据的 Redis 命令模板。 每个列表元素代表一个命令名称或其参数。<br/>例如，要通过键 `msgs` 将消息体推送到 Redis 列表中，数组元素应该是： `rpush`, `msgs`, `${'{'}payload{'}'}`。"},rocketmq:{servers:"将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/>主机名具有以下形式：`Host[:Port]`。<br/>如果未指定 `[:Port]`，则使用 RocketMQ 默认端口 9876。",access_key:"RocketMQ 服务器的 `accessKey`。",secret_key:"RocketMQ 服务器的 `secretKey`。",security_token:"RocketMQ 服务器安全令牌",topic:"RocketMQ 主题",refresh_interval:"RocketMQ 主题路由更新间隔。",send_buffer:"RocketMQ 驱动的套字节发送消息的缓冲区大小",template:"模板, 默认为空，为空时将会将整个消息转发给 RocketMQ。 <br/>模板可以是任意带有占位符的合法字符串, 例如:<br/>- ${'{'}id{'}'}, ${'{'}username{'}'}, ${'{'}clientid{'}'}, ${'{'}timestamp{'}'}<br/>- {'{'}\"id\" : ${'{'}id{'}'}, \"username\" : ${'{'}username{'}'}{'}'}",sync_timeout:"RocketMQ 驱动同步调用的超时时间。",namespace:"如果你正在使用阿里云的 RocketMQ 服务并且启用了命名空间，或者你在你自己的 RocketMQ 服务里配置了命名空间，那么你必须配置命名空间字段。对于阿里云的 RocketMQ 服务来说，命名空间就是实例 ID。",strategy:"生产者密钥分派策略，默认为 `roundrobin`，支持占位符。"},tdengine:{server:"将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/>主机名具有以下形式：`Host[:Port]`。<br/>如果未指定 `[:Port]`，则使用 TDengine 默认端口 6041。",sql:"SQL 模板",token:"连接到 TDengine Cloud 时使用的令牌。<br/>如果提供了令牌，它将覆盖用户名和密码的认证方式。"},sqlserver:{server:"将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/>主机名具有以下形式：`Host[:Port]`。<br/>如果未指定 `[:Port]`，则使用 SQL Server 默认端口 1433。",driver:"SQL Server Driver 名称",sql:"SQL 模板"},iotdb:{base_url:"外部 IoTDB 服务的 REST 接口的基础 URL。<br/>URL 具有以下形式：`http://Host:Port`",iotdb_version:"要连接的 IoTDB 系统的版本。",enable_pipelining:"一个正整数。是否连续发送 HTTP 请求，当设置为 1 时，这意味着每次发送 HTTP 请求后，您需要等待服务器返回，然后继续发送下一个请求。",connect_timeout:"连接到 IoTDB 服务器时的超时时间。",timestamp:"支持使用 ${'{'}var{'}'} 格式的占位符，要求是时间戳格式。也可以使用以下特殊字符插入系统时间：<br/>- `now`: 当前毫秒级时间戳<br/>- `now_ms`: 当前毫秒级时间戳<br/>- `now_us`: 当前微秒级时间戳<br/>- `now_ns`: 当前纳秒级时间戳",measurement:"也称 Measurement，支持使用 ${'{'}var{'}'} 格式的占位符。",data_type:"插入值的数据类型。支持的类型：boolean、int32、int64、float、double、text。",value:"要插入的值，支持使用 ${'{'}var{'}'} 格式的占位符。",device_id:"应插入此数据的固定设备名称。如果为空，则必须在规则操作中设置，消息本身中设置，或从主题中提取。",is_aligned:"是否对齐时间序列",recv_timeout:"接收 IoTDB Thrift 服务器的超时时间。"},opents:{server:"服务器的地址。",summary:"是否返回摘要信息。",details:"是否返回详细信息。",timestamp:"秒级或毫秒级时间戳，支持 ${'{'}var{'}'} 格式的占位符。",metric:"度量的名称，应为时间序列数据的唯一标识符，支持 ${'{'}var{'}'} 格式的占位符，",tags:"附加元数据的标签，每个标签都是一个键值对，采用 `key=value,key2=value2` 的格式进行配置，并支持 ${'{'}var{'}'} 形式的占位符。",value:"数据点的值，支持 ${'{'}var{'}'} 格式的占位符。它代表实际的测量或观察值。"},oracle:{sql:"SQL 模板。模板中描述消息元数据和有效载荷的字符串可以包含占位符。这些占位符在插入时不会做任何检查和格式转换，所以请务必确保插入值被正确地格式化和转义。",sid:"Oracle Database SID 名称",server:"将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/>主机名具有以下形式：`Host[:Port]`。<br/>如果未指定 `[:Port]`，则使用 Oracle Database 默认端口 1521。"},rabbitmq:{server:"你想要连接的 RabbitMQ 服务器地址（例如，localhost）。",port:"RabbitMQ 服务器监听的端口号（默认为 5672）。",exchange:"消息将被发送到的 RabbitMQ 交换机的名称。",routing_key:"用于将消息路由到 RabbitMQ 交换机的正确队列的路由键。",virtual_host:"连接到 RabbitMQ 服务器时要使用的虚拟主机。",heartbeat:"发送心跳消息到 RabbitMQ 服务器的时间间隔。",delivery_mode:"发布到 RabbitMQ 的消息的传递模式。非持久性的传递模式适用于不需要在 RabbitMQ 重启时保持持久性的消息，而持久性的传递模式适用于必须在 RabbitMQ 重启时保持持久性的消息。",wait_for_publish_confirmations:"使用发布者确认时，是否要等待 RabbitMQ 确认消息。",publish_confirmation_timeout:"使用发布者确认时等待 RabbitMQ 确认消息发布的超时时间。",timeout:"等待建立连接的超时时间。",payload_template:"发送消息到 RabbitMQ 之前格式化消息有效载荷的模板。模板占位符（例如 ${'{'}field1.sub_field{'}'} ）将被替换为相应字段的值。如果为空，则整个输入消息将被用作有效载荷，格式化为 JSON 文本。此行为相当于将 ${'{'}.{'}'} 指定为有效载荷模板。",queue:"RabbitMQ 队列名称。",no_ack:"在从 RabbitMQ 消费消息时是否使用 `no_ack` 模式。"},pulsar:{servers:"以逗号分隔的 <code>scheme://host[:port]</code> 格式的 Pulsar URL 列表，支持的 scheme 有 <code>pulsar://</code> （默认）和<code>pulsar+ssl://</code>。默认端口：6650。",pulsar_topic:"Pulsar 主题名称",strategy:"设置消息发布时的 Pulsar 分区选择策略。<br/><code>random</code>: 为每个消息随机选择一个分区。<br/><code>roundrobin</code>: 依次为每条信息挑选可用的 producer。<br/><code>key_dispatch</code>: 将待选择分区的编码进行哈希，并存储在一批信息中第一条信息的 Pulsar 信息密钥中。",compression:"压缩方法。",message_key:"生成 Pulsar 消息 Key 的模版。",message_value:"生成 Pulsar 消息 Value 的模版。",sync_timeout:"同步发布时，从 Pulsar 接收发送回执的最长等待时间。",retention_period:"指定在与 Pulsar broker 断开连接时缓冲消息的持续时间。请合理设置该值，时间设置越久，需要的内存/磁盘的使用量越高。",send_buffer:"TCP socket 的发送缓存调优，高吞吐量下建议保留默认值。",max_batch_bytes:"每个批次可收集的最大消息字节数。EMQX 将默认值设为小于 5 MB，以便补偿编码开销，特别是在处理较小的消息时。当单条消息的大小超过该限制时，会做为单独批次处理，即该批次中仅包含这条消息。",connect_timeout:"建立 TCP 连接时的最大等待时长（若启用认证，这个等待时长也包含完成认证所需时间）。",mode:"消息缓存模式。<br/><code>memory</code>: 所有的消息都缓存在内存里。如果 EMQX 服务重启，缓存的消息会丢失。<br/><code>disk</code>: 缓存到磁盘上。EMQX 重启后会继续发送重启前未发送完成的消息。<br/><code>hybrid</code>: 先将消息缓存在内存中，当内存中的消息堆积超过一定限制（配置项 <code>segment_bytes</code> 描述了该限制）后，后续的消息会缓存到磁盘上。如果 EMQX 服务重启，缓存消息会丢失。",per_partition_limit:"为每个 Pulsar 分区设置的最大缓存字节数。当超过这个上限之后，老的消息会被丢弃，以便接收新的消息。",segment_bytes:"当缓存模式是 <code>disk</code> 或 <code>hybrid</code> 时适用。该配置用于指定缓存到磁盘上的文件的大小。",authentication_jwt:"JWT 认证令牌。",max_inflight:"生产者在等待接收回执前可以发送给每个分区的最大消息批次数量。<br/>设置更高的值可以提高吞吐量。"},azure_event_hub_producer:{bootstrap_hosts:"用于引导客户端的 Azure Event Hubs Kafka <code>host[:port]</code>命名空间端点的逗号分隔列表。默认端口号为 9093。",connect_timeout:"TCP 连接建立的最大等待时间（包括启用身份验证的时间）。",min_metadata_refresh_interval:"客户端在刷新 Azure Event Hubs Kafka 代理和主题元数据之前必须等待的最小时间间隔。设置太小的值可能会对 Azure Event Hubs 造成额外的负载。",metadata_request_timeout:"从 Azure Event Hubs 获取元数据时的最大等待时间。",password:'用于连接到 Azure Event Hubs 的连接字符串。应为命名空间共享访问策略的 "连接字符串 - 主键"。',topic:"事件中心名称",max_batch_bytes:"在 Azure Event Hubs 消息批次中收集的最大字节数。大多数 Azure Event Hubs 代理的默认限制为 1 MB 批次大小。EMQX 的默认值小于 1 MB，以补偿 Azure Event Hubs 消息编码开销（特别是当每个单独消息非常小时）。当单个消息超过限制时，仍然会发送（作为单个元素批次）。",partition_strategy:`分区策略用于告诉生产者如何将消息分派到 Azure Event Hubs 分区。
+实际数量可能小于指定的值。`,connect_timeout:"连接 GCP 服务器的超时时间。"},hstreamdb:{url:"HStreamDB 服务器的 URL。使用 gRPC HTTP 服务器地址。",partition_key:"HStreamDB 分区键。支持占位符。",grpc_flush_timeout:"刷新 gRPC 调用到 HStreamDB 服务器的时间间隔。",aggregation_pool_size:"记录聚合池的大小。增大聚合池可提升并行处理能力，但可能会因批处理变小而影响效率。",max_batches:"刷新队列中最大未确认批次数。",writer_pool_size:"写入池大小。扩大池规模可增加并行化和同时写入操作，可能提升吞吐量。但需权衡内存消耗和资源竞争。",batch_interval:"两个连续（批量）请求之间的最大间隔。",record_template:"将被转发到 HStreamDB 的 HStream record 模板。支持占位符。<br/>注意：当使用 `raw record` 模板（意味着数据不是有效的 JSON）时，应该在 HStream 中使用 `read` 或 `subscription` 来获取数据。",parameters_batch_size:"单个请求中可发送的插入数据子句的最大数量。"},influxdb:{server:"将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/><br/>主机名具有以下形式：`Host[:Port]`。<br/><br/>如果未指定 `[:Port]`，则使用 InfluxDB 默认端口 8086。",token:"InfluxDB token。",org:"InfluxDB 组织名称。",bucket:"InfluxDB bucket 名称。",write_syntax:"使用 InfluxDB API Line Protocol 写入 InfluxDB 的数据，支持占位符，参考 [InfluxDB 2.3 Line Protocol](https://docs.influxdata.com/influxdb/v2.3/reference/syntax/line-protocol/) 及 [InfluxDB 1.8 Line Protocol](https://docs.influxdata.com/influxdb/v1.8/write_protocols/line_protocol_tutorial/) <br/>TLDR: <br/>```<measurement>[,<tag_key>=<tag_value>[,<tag_key>=<tag_value>]] <field_key>=<field_value>[,<field_key>=<field_value>] [<timestamp>]```<br/>注意，整形数值占位符后需要添加一个字符 `i` 类型标识。例如 `${'{'}payload.int_value{'}'}i`",precision:"InfluxDB 时间精度。"},datalayers:{write_syntax:"Datalayers 采用与 InfluxDB v1 完全兼容的行协议，为用户提供了熟悉且高效的数据写入方式。虽然兼容InfluxDB v1 的语法，但 Datalayers 在底层实现上有其独特之处，以优化性能和适应其特定的存储结构。参考 [InfluxDB Line Protocol](https://docs.datalayers.cn/datalayers/latest/development-guide/writing-with-influxdb-line-protocol.html)",precision:"Datalayers 时间精度。"},confluent_producer:{connect_timeout:"建立 TCP 连接时的最大等待时长（若启用认证，这个等待时长也包含完成认证所需时间）。",bootstrap_hosts:"用逗号分隔的 <code>host[:port]</code> 主机列表。默认端口号为 9092。",min_metadata_refresh_interval:"刷新 Kafka broker 和 Kafka 主题元数据的最短时间间隔。设置太小可能会增加 Kafka 压力。",metadata_request_timeout:"刷新元数据时最大等待时长。",topic:"Kafka 主题名称",kafka_headers:`请提供用作 Kafka Headers 的占位符<br/>例如：<code>\${'{'}pub_props{'}'}</code><br/>注意占位符的值必须是一个对象：<br/>\`{'{'}"foo": "bar"{'}'}\``,kafka_header_value_encode_mode:"Kafka Headers 的值编码类型：<br/>- `NONE`：仅将二进制值添加到 Kafka Headers；<br/>- `JSON`：仅将 JSON 值添加到 Kafka Headers，并在发送之前将其编码为 JSON 字符串。",kafka_ext_headers:"请提供更多的键值对，用于 Kafka Headers。<br/>这里的键值对将与 `kafka_headers` 字段的值合并后发送到 Kafka。",key:"生成 Kafka 消息键的模版。如果模版生成后为空值，则会使用 Kafka 的 <code>NULL</code> ，而非空字符串。",value:"生成 Kafka 消息的值的模版。如果模版生成后为空值，则会使用 Kafka 的 <code>NULL</code>，而非空字符串。",partition_strategy:"设置消息发布时应该如何选择 Kafka 分区。<br/><code>random</code>: 为每个消息随机选择一个分区。<br/><code>key_dispatch</code>：对 Kafka 消息键进行哈希，以得到一个分区号。",max_batch_bytes:"最大消息批量字节数。大多数 Kafka 环境的默认最低值是 1 MB，EMQX 的默认值比 1 MB 更小是因为需要补偿 Kafka 消息编码所需要的额外字节（尤其是当每条消息都很小的情况下）。当单个消息的大小超过该限制时，它仍然会被发送，（相当于该批量中只有单个消息）。",required_acks:"设置 Kafka leader 在返回给 EMQX 确认之前需要等待多少个 follower 的确认。<br/><code>all_isr</code>: 需要所有的在线复制者都确认。<br/><code>leader_only</code>: 仅需要分区 leader 确认。<br/><code>none</code>: 无需 Kafka 回复任何确认。",partition_count_refresh_interval:"配置 Kafka 刷新分区数量的时间间隔。<br/>EMQX 发现 Kafka 分区数量增加后，会开始按 <code>partition_strategy</code> 配置，把消息发送到新的分区中。",max_inflight:"设置 Kafka 生产者（每个分区一个）在收到 Kafka 的确认前最多发送多少个请求（批量）。调大这个值通常可以增加吞吐量，但是，当该值设置大于 1 时存在消息乱序的风险。",sync_query_timeout:"同步查询的超时时间。仅当请求模式配置为'同步'时才使用该配置。",mode:"消息缓存模式。<br/><code>memory</code>: 所有的消息都缓存在内存里。如果 EMQX 服务重启，缓存的消息会丢失。<br/><code>disk</code>: 缓存到磁盘上。EMQX 重启后会继续发送重启前未发送完成的消息。<br/><code>hybrid</code>: 先将消息缓存在内存中，当内存中的消息堆积超过一定限制（配置项 <code>segment_bytes</code> 描述了该限制）后，后续的消息会缓存到磁盘上。与 <code>memory</code> 模式一样，如果 EMQX 服务重启，缓存的消息会丢失。",per_partition_limit:"为每个 Kafka 分区设置的最大缓存字节数。当超过这个上限之后，老的消息会被丢弃，为新的消息腾出空间。",segment_bytes:"当缓存模式是 <code>disk</code> 或 <code>hybrid</code> 时适用。该配置用于指定缓存到磁盘上的文件的大小。",compression:"压缩方法。",partitions_limit:"限制生产者能够发送消息的最大分区数量。"},kafka_producer:{bootstrap_hosts:"用逗号分隔的 <code>host[:port]</code> 主机列表。默认端口号为 9092。",authentication:"认证参数。",connect_timeout:"建立 TCP 连接时的最大等待时长（若启用认证，这个等待时长也包含完成认证所需时间）。",min_metadata_refresh_interval:"刷新 Kafka broker 和 Kafka 主题元数据的最短时间间隔。设置太小可能会增加 Kafka 压力。",metadata_request_timeout:"刷新元数据时最大等待时长。",topic:"Kafka 主题名称",kafka_headers:`请提供用作 Kafka Headers 的占位符<br/>例如：<code>\${'{'}pub_props{'}'}</code><br/>注意占位符的值必须是一个对象：<br/>\`{'{'}"foo": "bar"{'}'}\``,kafka_header_value_encode_mode:"Kafka Headers 的值编码类型：<br/>- `NONE`：仅将二进制值添加到 Kafka Headers；<br/>- `JSON`：仅将 JSON 值添加到 Kafka Headers，并在发送之前将其编码为 JSON 字符串。",kafka_ext_headers:"请提供更多的键值对，用于 Kafka Headers。<br/>这里的键值对将与 `kafka_headers` 字段的值合并后发送到 Kafka。",key:"生成 Kafka 消息键的模版。如果模版生成后为空值，则会使用 Kafka 的 <code>NULL</code> ，而非空字符串。",value:"生成 Kafka 消息的值的模版。如果模版生成后为空值，则会使用 Kafka 的 <code>NULL</code>，而非空字符串。",kafka_message_timestamp:"生成 Kafka 消息时间戳的模版。该时间必需是一个整型数值（可以是字符串格式）例如 <code>1661326462115</code> 或 <code>'1661326462115'</code>。当所需的输入字段不存在，或不是一个整型时，则会使用当前系统时间。",compression:"压缩方法。",partition_strategy:"设置消息发布时应该如何选择 Kafka 分区。<br/><code>random</code>: 为每个消息随机选择一个分区。<br/><code>key_dispatch</code>：对 Kafka 消息键进行哈希，以得到一个分区号。",max_batch_bytes:"最大消息批量字节数。大多数 Kafka 环境的默认最低值是 1 MB，EMQX 的默认值比 1 MB 更小是因为需要补偿 Kafka 消息编码所需要的额外字节（尤其是当每条消息都很小的情况下）。当单个消息的大小超过该限制时，它仍然会被发送，（相当于该批量中只有单个消息）。",required_acks:"设置 Kafka leader 在返回给 EMQX 确认之前需要等待多少个 follower 的确认。<br/><code>all_isr</code>: 需要所有的在线复制者都确认。<br/><code>leader_only</code>: 仅需要分区 leader 确认。<br/><code>none</code>: 无需 Kafka 回复任何确认。",partition_count_refresh_interval:"配置 Kafka 刷新分区数量的时间间隔。<br/>EMQX 发现 Kafka 分区数量增加后，会开始按 <code>partition_strategy</code> 配置，把消息发送到新的分区中。",max_inflight:"设置 Kafka 生产者（每个分区一个）在收到 Kafka 的确认前最多发送多少个请求（批量）。调大这个值通常可以增加吞吐量，但是，当该值设置大于 1 时存在消息乱序的风险。",sync_query_timeout:"同步查询的超时时间。仅当请求模式配置为'同步'时才使用该配置。",mode:"消息缓存模式。<br/><code>memory</code>: 所有的消息都缓存在内存里。如果 EMQX 服务重启，缓存的消息会丢失。<br/><code>disk</code>: 缓存到磁盘上。EMQX 重启后会继续发送重启前未发送完成的消息。<br/><code>hybrid</code>: 先将消息缓存在内存中，当内存中的消息堆积超过一定限制（配置项 <code>segment_bytes</code> 描述了该限制）后，后续的消息会缓存到磁盘上。与 <code>memory</code> 模式一样，如果 EMQX 服务重启，缓存的消息会丢失。",per_partition_limit:"为每个 Kafka 分区设置的最大缓存字节数。当超过这个上限之后，老的消息会被丢弃，为新的消息腾出空间。",segment_bytes:"当缓存模式是 <code>disk</code> 或 <code>hybrid</code> 时适用。该配置用于指定缓存到磁盘上的文件的大小。",kafka_ext_header_key:"Kafka Headers 的键。支持使用 <code>${'{'}var{'}'}</code> 格式的占位符。",mechanism:"SASL 认证方法名称。",kerberos_principal:"SASL GSSAPI 认证方法的 Kerberos principal，例如 <code>client_name{'@'}MY.KERBEROS.REALM.MYDOMAIN.COM</code>注意：这里使用的 realm 需要配置在 EMQX 服务器的 /etc/krb5.conf 中",kerberos_keytab_file:"SASL GSSAPI 认证方法的 Kerberos keytab 文件。注意：该文件需要上传到 EMQX 服务器中，且运行 EMQX 服务的系统账户需要有读取权限。",kafka_ext_header_value:"Kafka Headers 的值。支持使用 <code>${'{'}var{'}'}</code> 格式的占位符。",partitions_limit:"限制生产者能够发送消息的最大分区数量。"},kafka_consumer:{bootstrap_hosts:"用逗号分隔的 <code>host[:port]</code> 主机列表。默认端口号为 9092。",key_encoding_mode:"通过 MQTT 转发之前，如何处理 Kafka 消息的 Key。<code>none</code> 使用 Kafka 消息中的 Key 原始值，不进行编码。  注意：在这种情况下，Key 必须是一个有效的 UTF-8 字符串。<br/><code>base64</code> 对收到的密钥或值使用 base-64 编码。",value_encoding_mode:"通过 MQTT 转发之前，如何处理 Kafka 消息的 Value。<code>none</code> 使用 Kafka 消息中的 Value 原始值，不进行编码。  注意：在这种情况下，Value 必须是一个有效的 UTF-8 字符串。<br/><code>base64</code> 对收到的 Value 使用 base-64 编码。",offset_reset_policy:"如不存在偏移量历史记录或历史记录失效，消费者应使用哪个偏移量开始消费。",min_metadata_refresh_interval:"刷新 Kafka broker 和 Kafka 主题元数据的最短时间间隔。设置太小可能会增加 Kafka 压力。",metadata_request_timeout:"刷新元数据时最大等待时长。",connect_timeout:"建立 TCP 连接时的最大等待时长（若启用认证，这个等待时长也包含完成认证所需时间）。",max_batch_bytes:"设置每次从 Kafka 拉取数据的字节数。<br/>消费者按批次获取消息，如果获取的第一个非空分区中的第一个记录批次大小大于这个值，该记录批次仍会被返回，以确保消费者能够继续处理。因此，这并不是一个绝对的最大值限制。如果需要实现最小延迟，可将该值设为 `1`",offset_commit_interval_seconds:"指定 Kafka 消费组偏移量提交的时间间隔。",topic:"Kafka 主题名称",group_id:"用于此 Source 的消费者组 ID。如果未指定，系统将自动生成一个基于 Source 名称的 ID。",max_wait_time:"等待 Kafka broker 发送响应对象的最大时间。"},mongodb:{collection:"数据将被存储到的集合",payload_template:"用于格式化写入 MongoDB 的消息模板。 如果未定义，规则引擎会使用 JSON 格式序列化所有的可见输入，例如 clientid, topic, payload 等。",auth_source:"与用户证书关联的数据库名称。",use_legacy_protocol:"是否使用 MongoDB 的旧协议与数据库通信。默认情况下，系统会尝试自动确定是否支持新协议。",srv_record:"使用 DNS SRV 记录。",max_overflow:"当连接池中所有线程都被占用时，可以创建的最大附加工作线程数。这有助于通过允许更多并发连接到 MongoDB 服务器来管理暂时的工作负载峰值。",overflow_ttl:"当池内工人太多时，等待多久清除多余工人。",overflow_check_period:'检查是否有超过配置的工人的周期（"溢出"）。',local_threshold:"在多个合适的 MongoDB 实例中进行选择的延迟窗口的大小。",connect_timeout:"超时重连的等待时间。",socket_timeout:"在尝试超时之前，在套接字上尝试发送或接收的持续时间。",server_selection_timeout:"指定在抛出异常之前为服务器选择阻断多长时间。",wait_queue_timeout:"工作者等待连接可用的最长时间。",heartbeat_frequency:"控制驱动程序何时检查 MongoDB 部署的状态。指定检查的间隔时间，从上一次检查结束到下一次检查开始计算。如果连接数增加（例如，如果你增加池子的大小，就会发生这种情况），你可能也需要增加这个周期，以避免在 MongoDB 日志文件中创建太多的日志条目。",min_heartbeat_frequency:"心跳间的最小间隙",server:"将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/>主机名具有以下形式：`Host[:Port]`。<br/>如果未指定 `[:Port]`，则使用 MongoDB 默认端口 27017。",w_mode:"写模式。",servers:"集群将要连接的节点列表。 节点之间用逗号分隔，如：`Node[,Node].`<br/>每个节点的配置为：将要连接的 IPv4 或 IPv6 地址或主机名。<br/>主机名具有以下形式：`Host[:Port]`。<br/>如果未指定 `[:Port]`，则使用 MongoDB 默认端口 27017。",replica_set_name:"副本集的名称。",r_mode:"读模式。"},mysql:{server:"将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/>主机名具有以下形式：`Host[:Port]`。<br/>如果未指定 `[:Port]`，则使用 MySQL 默认端口 3306。",sql:"SQL 模板"},pgsql:{server:"将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/>主机名具有以下形式：`Host[:Port]`。<br/>如果未指定 `[:Port]`，则使用默认端口 5432。",sql:"SQL 模板"},redis:{server:"将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/>主机名具有以下形式：`Host[:Port]`。<br/>如果未指定 `[:Port]`，则使用 Redis 默认端口 6379。",servers:"集群将要连接的节点列表。 节点之间用逗号分隔，如：`Node[,Node].`<br/>每个节点的配置为：将要连接的 IPv4 或 IPv6 地址或主机名。<br/>主机名具有以下形式：`Host[:Port]`。<br/>如果未指定 `[:Port]`，则使用 Redis 默认端口 6379。",sentinel:"哨兵模式。当 Redis 服务运行在哨兵模式下，该配置必须设置为 'sentinel'。",command_template:"用于推送数据的 Redis 命令模板。 每个列表元素代表一个命令名称或其参数。<br/>例如，要通过键 `msgs` 将消息体推送到 Redis 列表中，数组元素应该是： `rpush`, `msgs`, `${'{'}payload{'}'}`。"},rocketmq:{servers:"将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/>主机名具有以下形式：`Host[:Port]`。<br/>如果未指定 `[:Port]`，则使用 RocketMQ 默认端口 9876。",access_key:"RocketMQ 服务器的 `accessKey`。",secret_key:"RocketMQ 服务器的 `secretKey`。",security_token:"RocketMQ 服务器安全令牌",topic:"RocketMQ 主题",refresh_interval:"RocketMQ 主题路由更新间隔。",send_buffer:"RocketMQ 驱动的套字节发送消息的缓冲区大小",template:"模板, 默认为空，为空时将会将整个消息转发给 RocketMQ。 <br/>模板可以是任意带有占位符的合法字符串, 例如:<br/>- ${'{'}id{'}'}, ${'{'}username{'}'}, ${'{'}clientid{'}'}, ${'{'}timestamp{'}'}<br/>- {'{'}\"id\" : ${'{'}id{'}'}, \"username\" : ${'{'}username{'}'}{'}'}",sync_timeout:"RocketMQ 驱动同步调用的超时时间。",namespace:"如果你正在使用阿里云的 RocketMQ 服务并且启用了命名空间，或者你在你自己的 RocketMQ 服务里配置了命名空间，那么你必须配置命名空间字段。对于阿里云的 RocketMQ 服务来说，命名空间就是实例 ID。",strategy:"生产者密钥分派策略，默认为 `roundrobin`，支持占位符。"},tdengine:{server:"将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/>主机名具有以下形式：`[http[s]://]Host[:Port]`。<br/>如果未指定 `[:Port]`，则使用 TDengine 默认端口 6041。",sql:"SQL 模板",token:"连接到 TDengine Cloud 时使用的令牌。<br/>如果提供了令牌，它将覆盖用户名和密码的认证方式。"},sqlserver:{server:"将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/>主机名具有以下形式：`Host[:Port]`。<br/>如果未指定 `[:Port]`，则使用 SQL Server 默认端口 1433。",driver:"SQL Server Driver 名称",sql:"SQL 模板"},iotdb:{base_url:"外部 IoTDB 服务的 REST 接口的基础 URL。<br/>URL 具有以下形式：`http://Host:Port`",iotdb_version:"要连接的 IoTDB 系统的版本。",enable_pipelining:"一个正整数。是否连续发送 HTTP 请求，当设置为 1 时，这意味着每次发送 HTTP 请求后，您需要等待服务器返回，然后继续发送下一个请求。",connect_timeout:"连接到 IoTDB 服务器时的超时时间。",timestamp:"支持使用 ${'{'}var{'}'} 格式的占位符，要求是时间戳格式。也可以使用以下特殊字符插入系统时间：<br/>- `now`: 当前毫秒级时间戳<br/>- `now_ms`: 当前毫秒级时间戳<br/>- `now_us`: 当前微秒级时间戳<br/>- `now_ns`: 当前纳秒级时间戳",measurement:"也称 Measurement，支持使用 ${'{'}var{'}'} 格式的占位符。",data_type:"插入值的数据类型。支持的类型：boolean、int32、int64、float、double、text。",value:"要插入的值，支持使用 ${'{'}var{'}'} 格式的占位符。",device_id:"应插入此数据的固定设备名称。如果为空，则必须在规则操作中设置，消息本身中设置，或从主题中提取。",is_aligned:"是否对齐时间序列",recv_timeout:"接收 IoTDB Thrift 服务器的超时时间。"},opents:{server:"服务器的地址。",summary:"是否返回摘要信息。",details:"是否返回详细信息。",timestamp:"秒级或毫秒级时间戳，支持 ${'{'}var{'}'} 格式的占位符。",metric:"度量的名称，应为时间序列数据的唯一标识符，支持 ${'{'}var{'}'} 格式的占位符，",tags:"附加元数据的标签，每个标签都是一个键值对，采用 `key=value,key2=value2` 的格式进行配置，并支持 ${'{'}var{'}'} 形式的占位符。",value:"数据点的值，支持 ${'{'}var{'}'} 格式的占位符。它代表实际的测量或观察值。"},oracle:{sql:"SQL 模板。模板中描述消息元数据和有效载荷的字符串可以包含占位符。这些占位符在插入时不会做任何检查和格式转换，所以请务必确保插入值被正确地格式化和转义。",sid:"Oracle Database SID 名称",server:"将要连接的 IPv4 或 IPv6 地址，或者主机名。<br/>主机名具有以下形式：`Host[:Port]`。<br/>如果未指定 `[:Port]`，则使用 Oracle Database 默认端口 1521。"},rabbitmq:{server:"你想要连接的 RabbitMQ 服务器地址（例如，localhost）。",port:"RabbitMQ 服务器监听的端口号（默认为 5672）。",exchange:"消息将被发送到的 RabbitMQ 交换机的名称。",routing_key:"用于将消息路由到 RabbitMQ 交换机的正确队列的路由键。",virtual_host:"连接到 RabbitMQ 服务器时要使用的虚拟主机。",heartbeat:"发送心跳消息到 RabbitMQ 服务器的时间间隔。",delivery_mode:"发布到 RabbitMQ 的消息的传递模式。非持久性的传递模式适用于不需要在 RabbitMQ 重启时保持持久性的消息，而持久性的传递模式适用于必须在 RabbitMQ 重启时保持持久性的消息。",wait_for_publish_confirmations:"使用发布者确认时，是否要等待 RabbitMQ 确认消息。",publish_confirmation_timeout:"使用发布者确认时等待 RabbitMQ 确认消息发布的超时时间。",timeout:"等待建立连接的超时时间。",payload_template:"发送消息到 RabbitMQ 之前格式化消息有效载荷的模板。模板占位符（例如 ${'{'}field1.sub_field{'}'} ）将被替换为相应字段的值。如果为空，则整个输入消息将被用作有效载荷，格式化为 JSON 文本。此行为相当于将 ${'{'}.{'}'} 指定为有效载荷模板。",queue:"RabbitMQ 队列名称。",no_ack:"在从 RabbitMQ 消费消息时是否使用 `no_ack` 模式。"},pulsar:{servers:"以逗号分隔的 <code>scheme://host[:port]</code> 格式的 Pulsar URL 列表，支持的 scheme 有 <code>pulsar://</code> （默认）和<code>pulsar+ssl://</code>。默认端口：6650。",pulsar_topic:"Pulsar 主题名称",strategy:"设置消息发布时的 Pulsar 分区选择策略。<br/><code>random</code>: 为每个消息随机选择一个分区。<br/><code>roundrobin</code>: 依次为每条信息挑选可用的 producer。<br/><code>key_dispatch</code>: 将待选择分区的编码进行哈希，并存储在一批信息中第一条信息的 Pulsar 信息密钥中。",compression:"压缩方法。",message_key:"生成 Pulsar 消息 Key 的模版。",message_value:"生成 Pulsar 消息 Value 的模版。",sync_timeout:"同步发布时，从 Pulsar 接收发送回执的最长等待时间。",retention_period:"指定在与 Pulsar broker 断开连接时缓冲消息的持续时间。请合理设置该值，时间设置越久，需要的内存/磁盘的使用量越高。",send_buffer:"TCP socket 的发送缓存调优，高吞吐量下建议保留默认值。",max_batch_bytes:"每个批次可收集的最大消息字节数。EMQX 将默认值设为小于 5 MB，以便补偿编码开销，特别是在处理较小的消息时。当单条消息的大小超过该限制时，会做为单独批次处理，即该批次中仅包含这条消息。",connect_timeout:"建立 TCP 连接时的最大等待时长（若启用认证，这个等待时长也包含完成认证所需时间）。",mode:"消息缓存模式。<br/><code>memory</code>: 所有的消息都缓存在内存里。如果 EMQX 服务重启，缓存的消息会丢失。<br/><code>disk</code>: 缓存到磁盘上。EMQX 重启后会继续发送重启前未发送完成的消息。<br/><code>hybrid</code>: 先将消息缓存在内存中，当内存中的消息堆积超过一定限制（配置项 <code>segment_bytes</code> 描述了该限制）后，后续的消息会缓存到磁盘上。如果 EMQX 服务重启，缓存消息会丢失。",per_partition_limit:"为每个 Pulsar 分区设置的最大缓存字节数。当超过这个上限之后，老的消息会被丢弃，以便接收新的消息。",segment_bytes:"当缓存模式是 <code>disk</code> 或 <code>hybrid</code> 时适用。该配置用于指定缓存到磁盘上的文件的大小。",authentication_jwt:"JWT 认证令牌。",max_inflight:"生产者在等待接收回执前可以发送给每个分区的最大消息批次数量。<br/>设置更高的值可以提高吞吐量。"},azure_event_hub_producer:{bootstrap_hosts:"用于引导客户端的 Azure Event Hubs Kafka <code>host[:port]</code>命名空间端点的逗号分隔列表。默认端口号为 9093。",connect_timeout:"TCP 连接建立的最大等待时间（包括启用身份验证的时间）。",min_metadata_refresh_interval:"客户端在刷新 Azure Event Hubs Kafka 代理和主题元数据之前必须等待的最小时间间隔。设置太小的值可能会对 Azure Event Hubs 造成额外的负载。",metadata_request_timeout:"从 Azure Event Hubs 获取元数据时的最大等待时间。",password:'用于连接到 Azure Event Hubs 的连接字符串。应为命名空间共享访问策略的 "连接字符串 - 主键"。',topic:"事件中心名称",max_batch_bytes:"在 Azure Event Hubs 消息批次中收集的最大字节数。大多数 Azure Event Hubs 代理的默认限制为 1 MB 批次大小。EMQX 的默认值小于 1 MB，以补偿 Azure Event Hubs 消息编码开销（特别是当每个单独消息非常小时）。当单个消息超过限制时，仍然会发送（作为单个元素批次）。",partition_strategy:`分区策略用于告诉生产者如何将消息分派到 Azure Event Hubs 分区。
 
 <code>random</code>：随机选择每个消息的分区
 <code>key_dispatch</code>：将 Azure Event Hubs 消息键哈希到分区号`,required_acks:`Azure Event Hubs 分区领导者在向其追随者发送确认之前必须等待的所需确认
@@ -106,7 +106,7 @@ HGETALL mqtt_acl:\${username}`}},n={async:"Async",sync:"Sync",get:"GET",post:"PO
 When Enabled, messages will be buffered on disk when the bridge connection is down.
 When disabled the messages are buffered in RAM only.`,health_check_interval:"Health check interval.",inflight_window:"Query inflight window. When query_mode is set to async, this config has to be set to 1 if messages from the same MQTT client have to be strictly ordered.",query_mode:"Query mode. Optional 'sync/async', default 'async'.",request_ttl:"Starting from the moment when the request enters the buffer, if the request remains in the buffer for the specified time or is sent but does not receive a response or acknowledgement in time, the request is considered expired.",start_timeout:"Time interval to wait for an auto-started resource to become healthy before responding resource creation requests.",worker_pool_size:`The number of buffer workers. Only applicable for egress type bridges.
 For bridges only have ingress direction data flow, it can be set to 0 otherwise must be greater than 0.`,max_buffer_bytes:"Maximum number of bytes to buffer for each buffer worker.",password:"Password used for authentication with the external database.",pool_size:"Size of the connection pool towards the bridge target service.",prepare_statement:"Key-value list of SQL prepared statements.",ssl:"SSL connection settings.",username:"The username in the external database used for authentication or identification purposes.",database:"Database name.",tcp_keepalive:"Enable TCP keepalive for connector.<br/>The value is a comma-separated list of three numbers in the format of `Idle,Interval,Probes`<br/>- Idle: The number of seconds of idle time needed by a connection before the server begins to send out keep-alive probes (default on Linux is 7200).<br/>- Interval: The number of seconds between TCP keep-alive probes (default on Linux is 75).<br/>- Probes: The maximum number of TCP keep-alive probes to send before considering the connection as closed if no response is received from the other end (default on Linux is 9).<br/>For example \"240,30,5\" means: send TCP keepalive probes after 240 seconds of idle time, and send probes every 30 second. If there are no responses for 5 consecutive attempts, the connection should be closed.<br/>Default: 'none'",sndbuf:"Fine tune the socket send buffer. The default value is tuned for high throughput.",recbuf:"Fine tune the socket receive buffer. The default value is tuned for high throughput.",nodelay:"When set to `true`, TCP buffer is sent as soon as possible. Otherwise, the OS kernel may buffer small TCP packets for a while (40 ms by default).",pool_type:"The type of the pool. Can be one of `random`, `hash`.",max_retries:"Max retry times if an error occurs when sending a request.",memory_overload_protection:"This setting applies when the buffer mode is configured as <code>memory</code>. EMQX will automatically discard older buffered messages when it encounters high memory pressure. Note: This configuration is effective only on Linux systems.",disable_prepared_statements:"Disables the usage of prepared statements in the connections. Some endpoints, like PGBouncer or Supabase in Transaction mode, do not support session features such as prepared statements. For such connections, this option should be enabled.",health_check_topic:"Topic name used exclusively for more accurate health checks.",max_records:"Number of records (events) allowed per each aggregated object. Each aggregated upload will contain no more than that number of events, but may contain less.<br/>If event rate is high enough, there obviously may be more than one aggregated upload during the same time interval. These uploads will have different, but consecutive sequence numbers, which will be a part of S3 object key.",max_linger_time:"Maximum duration for a per-partition producer to wait for messages in order to collect a batch to buffer.<br/>The default value <code>0</code> means no wait. For non-memory buffer mode, it's advised to configure at least <code>5ms</code> for less IOPS.",max_linger_bytes:"Maximum number of bytes for a per-partition producer to wait for messages in order to collect a batch to buffer.",undefined_vars_as_null:"When writing to databases, treat undefined variables as NULL.<br/>When this option is enabled, if undefined variables (like `${'{'}var{'}'}`) are used in templates, they will be replaced with `NULL` instead of the string `undefined`. If this option is not enabled (default), the string `undefined` might be inserted.<br/>This option should always be `true` if possible; the default value `false` is only to ensure backward compatibility.",max_inactive:"Maximum amount of time without any activity that the HTTP driver will wait before attempting to reconnect."},mqtt:{bridge_mode:"This setting is only for MQTT protocol version older than 5.0, and the remote MQTT broker MUST support this feature. After being enabled, the remote broker will recognize the current connection as a bridge, that loop detection will be more effective and that retained messages will be propagated correctly.",clean_start:"Whether to start a clean session when reconnecting a remote broker for ingress bridge.",retry_interval:"Retry interval for QoS1/QoS2 messages if no ACK is received.",clientid_prefix:"The prefix used when the connector randomly generates a Client ID.",max_inflight:"The number of Unacked messages that can be simultaneously waited for during message publishing, in order to improve message delivery efficiency and throughput.",topic:"Message publishing topic, supports using ${'{'}field{'}'} syntax to extract variables and dynamically concatenate the topic.",source_topic:"Message subscription topics support the use of + and # wildcards. When EMQX is running in cluster mode or the connector is configured with a connection pool, shared subscriptions must be used to avoid message duplication.",payload:"For example: ${'{'}payload{'}'}, ${'{'}clientid{'}'}, ${'{'}topic{'}'} , ${'{'}username{'}'}, etc. Use fields according to the action requirements of your business and forwards the message as it is if it is empty.Supports reading data using ${'{'}field{'}'} syntax.",static_clientids:"Entries mapping EMQX node names to static client IDs. If any entries are defined, then only EMQX nodes matching those entries will start MQTT clients with the corresponding clientids.",node:"EMQX node name, e.g.: <code>emqx{'@'}10.0.0.1</code>.",ids:"Array of static client IDs assigned to this node."},http:{url:"The URL of the HTTP Connector.<br/>Template with variables is allowed in the path, but variables cannot be used in the host or port part.<br/>For example, `http://localhost:9901/${'{'}topic{'}'}` is allowed, but`http://${'{'}host{'}'}:9901/message` or `http://localhost:${'{'}port{'}'}/message`is not allowed.",body:"For example: ${'{'}payload{'}'}, ${'{'}clientid{'}'}, ${'{'}topic{'}'} , ${'{'}username{'}'}, etc. Use fields according to the action requirements of your business and forwards the message as it is if it is empty.",path:"The URL path for this Action.<br/>This path will be appended to the Connector's <code>url</code> configuration to form the full URL address.Template with variables is allowed in this option. For example, <code>/room/{'{'}$room_no{'}'}</code>"},cassandra:{keyspace:"Keyspace name to connect to.",servers:"The IPv4 or IPv6 address or the hostname to connect to.<br/>A host entry has the following form: `Host[:Port][,Host2:Port]`.<br/>The Cassandra default port 9042 is used if `[:Port]` is not specified.",cql:"CQL Template"},clickhouse:{batch_value_separator:"The default value ',' works for the VALUES format. You can also use other separator if other format is specified. See [INSERT INTO Statement](https://clickhouse.com/docs/en/sql-reference/statements/insert-into).",connect_timeout:"The timeout when connecting to the Clickhouse server.",url:"The HTTP URL to the Clickhouse server that you want to connect to (for example http://myhostname:8123)",sql:"The template string can contain ${'{'}field{'}'} placeholders for message metadata and payload field. Make sure that the inserted values are formatted and escaped correctly. [Prepared Statement](https://docs.emqx.com/en/enterprise/v5.0/data-integration/data-bridges.html#Prepared-Statement) is not supported."},dynamo:{template:`Template, the default value is empty. When this value is empty the whole message will be stored in the database.<br/>The template can be any valid JSON with placeholders and make sure all keys for table are here, example:<br/>  \`{'{'}"id" : "\${'{'}id{'}'}", "clientid" : "\${'{'}clientid{'}'}", "data" : "\${'{'}payload.data{'}'}"{'}'}\``,url:"The url of DynamoDB endpoint.",table:"DynamoDB Table.",aws_access_key_id:"Access Key ID for connecting to DynamoDB.",aws_secret_access_key:"AWS Secret Access Key for connecting to DynamoDB.",region:"Region of the AWS dynamo"},gcp_pubsub_producer:{pipelining:"A positive integer. Whether to send HTTP requests continuously, when set to 1, it means that after each HTTP request is sent, you need to wait for the server to return and then continue to send the next request.",connect_timeout:"The timeout when connecting to the GCP server.",service_account_json:"JSON containing the GCP Service Account credentials to be used with PubSub.<br/>When a GCP Service Account is created (as described in https://developers.google.com/identity/protocols/oauth2/service-account#creatinganaccount), you have the option of downloading the credentials in JSON form.  That's the file needed.",pubsub_topic:"The GCP PubSub topic to publish messages to.",payload_template:"The template for formatting the outgoing messages.  If undefined, will send all the available context in JSON format.",attributes_template:"The template for formatting the outgoing message attributes.  Undefined values will be rendered as empty string values.  Empty keys are removed from the attribute map.",ordering_key_template:"The template for formatting the outgoing message ordering key.  Undefined values will be rendered as empty string values.  This value will not be added to the message if it's empty."},gcp_pubsub_consumer:{topic:"GCP PubSub topic to consume from.",pipelining:"A positive integer. Whether to send HTTP requests continuously, when set to 1, it means that after each HTTP request is sent, you need to wait for the server to return and then continue to send the next request.",service_account_json:"JSON containing the GCP Service Account credentials to be used with PubSub.<br/>When a GCP Service Account is created (as described in https://developers.google.com/identity/protocols/oauth2/service-account#creatinganaccount), you have the option of downloading the credentials in JSON form.  That's the file needed.",pull_max_messages:`The maximum number of messages to retrieve from GCP PubSub in a single pull request.
- The actual number may be less than the specified value.`,connect_timeout:"The timeout when connecting to the GCP server."},hstreamdb:{url:"HStreamDB Server URL. Using gRPC http server address.",partition_key:"HStreamDB Partition Key. Placeholders supported.",grpc_flush_timeout:"Time interval for flushing gRPC calls to the HStreamDB server.",aggregation_pool_size:"The size of the record aggregation pool. A larger aggregation pool size can lead to enhanced parallelization but may also result in reduced efficiency due to smaller batch sizes.",max_batches:"Maximum number of unconfirmed batches in the flush queue.",writer_pool_size:"The size of the writer pool. A larger pool may increase parallelization and concurrent write operations, potentially boosting throughput. Trade-offs include greater memory consumption and possible resource contention.",batch_interval:"Maximum interval that is allowed between two successive (batch) request.",record_template:"The HStream record template to be forwarded to the HStreamDB. Placeholders supported.<br/>NOTE: When you use `raw record` template (which means the data is not a valid JSON), you should use `read` or `subscription` in HStream to get the data.",parameters_batch_size:"Maximum number of insert data clauses that can be sent in a single request."},influxdb:{server:"The IPv4 or IPv6 address or the hostname to connect to.<br/><br/>A host entry has the following form: `Host[:Port]`.<br/><br/>The InfluxDB default port 8086 is used if `[:Port]` is not specified.",token:"InfluxDB token.",org:"Organization name of InfluxDB.",bucket:"InfluxDB bucket name.",write_syntax:"Conf of InfluxDB line protocol to write data points. It is a text-based format that provides the measurement, tag set, field set, and timestamp of a data point, and placeholder supported. See also [InfluxDB 2.3 Line Protocol](https://docs.influxdata.com/influxdb/v2.3/reference/syntax/line-protocol/) and [InfluxDB 1.8 Line Protocol](https://docs.influxdata.com/influxdb/v1.8/write_protocols/line_protocol_tutorial/) <br/>TLDR:<br/>```<measurement>[,<tag_key>=<tag_value>[,<tag_key>=<tag_value>]] <field_key>=<field_value>[,<field_key>=<field_value>] [<timestamp>]```<br/>Please note that a placeholder for an integer value must be annotated with a suffix `i`. For example `${'{'}payload.int_value{'}'}i`.",precision:"InfluxDB time precision."},datalayers:{write_syntax:"Datalayers adopts a line protocol fully compatible with InfluxDB v1, providing users with a familiar and efficient method for data ingestion. While compatible with InfluxDB v1 syntax, Datalayers has its unique characteristics in its underlying implementation to optimize performance and adapt to its specific storage structure. For more information, refer to [InfluxDB Line Protocol](https://docs.datalayers.cn/datalayers/latest/development-guide/writing-with-influxdb-line-protocol.html).",precision:"Datalayers time precision."},confluent_producer:{connect_timeout:"Maximum wait time for TCP connection establishment (including authentication time if enabled).",bootstrap_hosts:"A comma separated list of Kafka <code>host[:port]</code> endpoints to bootstrap the client. Default port number is 9092.",min_metadata_refresh_interval:"Minimum time interval the client has to wait before refreshing Kafka broker and topic metadata. Setting too small value may add extra load on Kafka.",metadata_request_timeout:"Maximum wait time when fetching metadata from Kafka.",topic:"Kafka topic",kafka_headers:`Please provide a placeholder to be used as Kafka Headers<br/>e.g. <code>\${'{'}pub_props{'}'}</code><br/>Notice that the value of the placeholder must either be an object:<br/>\`{'{'}"foo": "bar"{'}'}\`<br/>`,kafka_header_value_encode_mode:"Kafka headers value encode mode:<br/>- `NONE`: only add binary values to Kafka headers;<br/>- `JSON`: only add JSON values to Kafka headers, and encode it to JSON strings before sending.",kafka_ext_headers:"Please provide more key-value pairs for Kafka headers.<br/>The key-value pairs here will be combined with the value of `kafka_headers` field before sending to Kafka.",key:"Template to render Kafka message key. If the template is rendered into a NULL value (i.e. there is no such data field in Rule Engine context) then Kafka's <code>NULL</code> (but not empty string) is used.",value:"Template to render Kafka message value. If the template is rendered into a NULL value (i.e. there is no such data field in Rule Engine context) then Kafka's <code>NULL</code> (but not empty string) is used.",partition_strategy:"Partition strategy is to tell the producer how to dispatch messages to Kafka partitions.<br/><code>random</code>: Randomly pick a partition for each message<br/><code>key_dispatch</code>: Hash Kafka message key to a partition number",max_batch_bytes:"Maximum bytes to collect in a Kafka message batch. Most of the Kafka brokers default to a limit of 1 MB batch size. EMQX's default value is less than 1 MB in order to compensate Kafka message encoding overheads (especially when each individual message is very small). When a single message is over the limit, it is still sent (as a single element batch).",required_acks:"Required acknowledgements for Kafka partition leader to wait for its followers before it sends back the acknowledgement to EMQX Kafka producer<br/><code>all_isr</code>: Require all in-sync replicas to acknowledge.<br/><code>leader_only</code>: Require only the partition-leader's acknowledgement.<br/><code>none</code>: No need for Kafka to acknowledge at all.",partition_count_refresh_interval:"The time interval for Kafka producer to discover increased number of partitions.<br/>After the number of partitions is increased in Kafka, EMQX will start taking the <br/>discovered partitions into account when dispatching messages per <code>partition_strategy</code>.",max_inflight:"Maximum number of batches allowed for Kafka producer (per-partition) to send before receiving acknowledgement from Kafka. Greater value typically means better throughput. However, there can be a risk of message reordering when this value is greater than 1.",query_mode:"Query mode. Optional 'sync/async', default 'async'.",sync_query_timeout:"This parameter defines the timeout limit for synchronous queries. It applies only when the bridge query mode is configured to 'sync'.",mode:"Message buffer mode.<br/><code>memory</code>: Buffer all messages in memory. The messages will be lost in case of EMQX node restart<br/><code>disk</code>: Buffer all messages on disk. The messages on disk are able to survive EMQX node restart.<br/><code>hybrid</code>: Buffer message in memory first, when up to certain limit (see <code>segment_bytes</code> config for more information), then start offloading messages to disk, Like <code>memory</code> mode, the messages will be lost in case of EMQX node restart.",per_partition_limit:"Number of bytes allowed to buffer for each Kafka partition. When this limit is exceeded, old messages will be dropped in a trade for credits for new messages to be buffered.",segment_bytes:"Applicable when buffer mode is set to <code>disk</code> or <code>hybrid</code>.<br/>This value is to specify the size of each on-disk buffer file.",compression:"Compression method.",partitions_limit:"Limits the maximum number of partitions to which a producer can send messages."},kafka_producer:{bootstrap_hosts:"A comma separated list of Kafka <code>host[:port]</code> endpoints to bootstrap the client. Default port number is 9092.",authentication:"Authentication configs.",connect_timeout:"Maximum wait time for TCP connection establishment (including authentication time if enabled).",min_metadata_refresh_interval:"Minimum time interval the client has to wait before refreshing Kafka broker and topic metadata. Setting too small value may add extra load on Kafka.",metadata_request_timeout:"Maximum wait time when fetching metadata from Kafka.",topic:"Kafka topic",kafka_headers:`Please provide a placeholder to be used as Kafka Headers<br/>e.g. <code>\${'{'}pub_props{'}'}</code><br/>Notice that the value of the placeholder must either be an object:<br/>\`{'{'}"foo": "bar"{'}'}\`<br/>`,kafka_header_value_encode_mode:"Kafka headers value encode mode:<br/>- `NONE`: only add binary values to Kafka headers;<br/>- `JSON`: only add JSON values to Kafka headers, and encode it to JSON strings before sending.",kafka_ext_headers:"Please provide more key-value pairs for Kafka headers.<br/>The key-value pairs here will be combined with the value of `kafka_headers` field before sending to Kafka.",key:"Template to render Kafka message key. If the template is rendered into a NULL value (i.e. there is no such data field in Rule Engine context) then Kafka's <code>NULL</code> (but not empty string) is used.",value:"Template to render Kafka message value. If the template is rendered into a NULL value (i.e. there is no such data field in Rule Engine context) then Kafka's <code>NULL</code> (but not empty string) is used.",kafka_message_timestamp:"Which timestamp to use. The timestamp is expected to be a millisecond precision Unix epoch which can be in string format, e.g. <code>1661326462115</code> or <code>'1661326462115'</code>. When the desired data field for this template is not found, or if the found data is not a valid integer, the current system timestamp will be used.",compression:"Compression method.",partition_strategy:"Partition strategy is to tell the producer how to dispatch messages to Kafka partitions.<br/><code>random</code>: Randomly pick a partition for each message<br/><code>key_dispatch</code>: Hash Kafka message key to a partition number",max_batch_bytes:"Maximum bytes to collect in a Kafka message batch. Most of the Kafka brokers default to a limit of 1 MB batch size. EMQX's default value is less than 1 MB in order to compensate Kafka message encoding overheads (especially when each individual message is very small). When a single message is over the limit, it is still sent (as a single element batch).",required_acks:"Required acknowledgements for Kafka partition leader to wait for its followers before it sends back the acknowledgement to EMQX Kafka producer<br/><code>all_isr</code>: Require all in-sync replicas to acknowledge.<br/><code>leader_only</code>: Require only the partition-leader's acknowledgement.<br/><code>none</code>: No need for Kafka to acknowledge at all.",partition_count_refresh_interval:"The time interval for Kafka producer to discover increased number of partitions.<br/>After the number of partitions is increased in Kafka, EMQX will start taking the <br/>discovered partitions into account when dispatching messages per <code>partition_strategy</code>.",max_inflight:"Maximum number of batches allowed for Kafka producer (per-partition) to send before receiving acknowledgement from Kafka. Greater value typically means better throughput. However, there can be a risk of message reordering when this value is greater than 1.",query_mode:"Query mode. Optional 'sync/async', default 'async'.",sync_query_timeout:"This parameter defines the timeout limit for synchronous queries. It applies only when the bridge query mode is configured to 'sync'.",mode:"Message buffer mode.<br/><code>memory</code>: Buffer all messages in memory. The messages will be lost in case of EMQX node restart<br/><code>disk</code>: Buffer all messages on disk. The messages on disk are able to survive EMQX node restart.<br/><code>hybrid</code>: Buffer message in memory first, when up to certain limit (see <code>segment_bytes</code> config for more information), then start offloading messages to disk, Like <code>memory</code> mode, the messages will be lost in case of EMQX node restart.",per_partition_limit:"Number of bytes allowed to buffer for each Kafka partition. When this limit is exceeded, old messages will be dropped in a trade for credits for new messages to be buffered.",segment_bytes:"Applicable when buffer mode is set to <code>disk</code> or <code>hybrid</code>.<br/>This value is to specify the size of each on-disk buffer file.",kafka_ext_header_key:"Key of the Kafka header. Placeholders in the format of <code>${'{'}var{'}'}</code> are supported.",mechanism:"SASL authentication mechanism.",kerberos_principal:"SASL GSSAPI authentication Kerberos principal. For example <code>client_name{'@'}MY.KERBEROS.REALM.MYDOMAIN.COM</code>, NOTE: The realm in use has to be configured in /etc/krb5.conf in EMQX nodes.",kerberos_keytab_file:"SASL GSSAPI authentication Kerberos keytab file path. NOTE: This file has to be placed in EMQX nodes, and the EMQX service runner user requires read permission.",kafka_ext_header_value:"Value of the Kafka header. Placeholders in the format of <code>${'{'}var{'}'}</code> are supported.",partitions_limit:"Limits the maximum number of partitions to which a producer can send messages."},kafka_consumer:{bootstrap_hosts:"A comma separated list of Kafka <code>host[:port]</code> endpoints to bootstrap the client. Default port number is 9092.",key_encoding_mode:"Defines how the key from the Kafka message is encoded before being forwarded via MQTT.<br/><code>none</code> Uses the key from the Kafka message unchanged.  Note: in this case, the key must be a valid UTF-8 string.<br/><code>base64</code> Uses base-64 encoding on the received key.",value_encoding_mode:"Defines how the value from the Kafka message is encoded before being forwarded via MQTT.<br/><code>none</code> Uses the value from the Kafka message unchanged.  Note: in this case, the value must be a valid UTF-8 string.<br/><code>base64</code> Uses base-64 encoding on the received value.",offset_reset_policy:"Defines from which offset a consumer should start fetching when there is no commit history or when the commit history becomes invalid.",min_metadata_refresh_interval:"Minimum time interval the client has to wait before refreshing Kafka broker and topic metadata. Setting too small value may add extra load on Kafka.",metadata_request_timeout:"Maximum wait time when fetching metadata from Kafka.",connect_timeout:"Maximum wait time for TCP connection establishment (including authentication time if enabled).",max_batch_bytes:"Set how many bytes to pull from Kafka in each fetch request.<br/>Messages are fetched in batches by the consumer, and if the first record batch in the first non-empty partition of the fetch is larger than this value, the record batch will still be returned to ensure that the consumer can make progress. As such, this is not an absolute maximum. Set `1` for minimal latency.",offset_commit_interval_seconds:"Defines the time interval between two offset commit requests sent for each consumer group.",topic:"Kafka topic",group_id:"Consumer group identifier to be used for this source. If omitted, one based off the source name will be automatically generated.",max_wait_time:"Maximum amount of time that is waited for the Kafka broker to send a fetch response."},mongodb:{collection:"The collection where data will be stored into",payload_template:"The template for formatting the outgoing messages.  If undefined, rule engine will use JSON format to serialize all visible inputs, such as clientid, topic, payload etc.",auth_source:"Database name associated with the user's credentials.",use_legacy_protocol:"Whether to use MongoDB's legacy protocol for communicating with the database. The default is to attempt to automatically determine if the newer protocol is supported.",srv_record:"Use DNS SRV record.",max_overflow:"The maximum number of additional workers that can be created when all workers in the pool are busy. This helps to manage temporary spikes in workload by allowing more concurrent connections to the MongoDB server.",overflow_ttl:'Period of time before workers that exceed the configured pool size ("overflow") to be terminated.',overflow_check_period:'Period for checking if there are more workers than configured ("overflow").',local_threshold:"The size of the latency window for selecting among multiple suitable MongoDB instances.",connect_timeout:"The duration to attempt a connection before timing out.",socket_timeout:"The duration to attempt to send or to receive on a socket before the attempt times out.",server_selection_timeout:"Specifies how long to block for server selection before throwing an exception.",wait_queue_timeout:"The maximum duration that a worker can wait for a connection to become available.",heartbeat_frequency:"Controls when the driver checks the state of the MongoDB deployment. Specify the interval between checks, counted from the end of the previous check until the beginning of the next one. If the number of connections is increased (which will happen, for example, if you increase the pool size), you may need to increase this period as well to avoid creating too many log entries in the MongoDB log file.",min_heartbeat_frequency:"Controls the minimum amount of time to wait between heartbeats.",server:"The IPv4 or IPv6 address or the hostname to connect to.<br/>A host entry has the following form: `Host[:Port]`.<br/>The MongoDB default port 27017 is used if `[:Port]` is not specified.",w_mode:"Write mode.",servers:"A Node list for Cluster to connect to. The nodes should be separated with commas, such as: `Node[,Node].`<br/>For each Node should be: The IPv4 or IPv6 address or the hostname to connect to.<br/>A host entry has the following form: `Host[:Port]`.<br/>The MongoDB default port 27017 is used if `[:Port]` is not specified.",replica_set_name:"Name of the replica set.",r_mode:"Read mode."},mysql:{server:"The IPv4 or IPv6 address or the hostname to connect to.<br/>A host entry has the following form: `Host[:Port]`.<br/>The MySQL default port 3306 is used if `[:Port]` is not specified.",sql:"SQL Template"},pgsql:{server:"The IPv4 or IPv6 address or the hostname to connect to.<br/>A host entry has the following form: `Host[:Port]`.<br/>The default port 5432 is used if `[:Port]` is not specified.",sql:"SQL Template"},redis:{server:"The IPv4 or IPv6 address or the hostname to connect to.<br/>A host entry has the following form: `Host[:Port]`.<br/>The Redis default port 6379 is used if `[:Port]` is not specified.",servers:"A Node list for Cluster to connect to. The nodes should be separated with commas, such as: `Node[,Node].`<br/>For each Node should be: The IPv4 or IPv6 address or the hostname to connect to.<br/>A host entry has the following form: `Host[:Port]`.<br/>The Redis default port 6379 is used if `[:Port]` is not specified.",sentinel:"Sentinel mode. Must be set to 'sentinel' when Redis server is running in sentinel mode.",command_template:"Redis command template used to export messages. Each list element stands for a command name or its argument.<br/>For example, to push payloads in a Redis list by key `msgs`, the elements should be the following:<br/>`rpush`, `msgs`, `${'{'}payload{'}'}`."},rocketmq:{servers:"The IPv4 or IPv6 address or the hostname to connect to.<br/>A host entry has the following form: `Host[:Port]`.<br/>The RocketMQ default port 9876 is used if `[:Port]` is not specified.",access_key:"RocketMQ server `accessKey`.",secret_key:"RocketMQ server `secretKey`.",security_token:"RocketMQ Server Security Token",topic:"RocketMQ Topic",refresh_interval:"RocketMQ Topic Route Refresh Interval.",send_buffer:"The socket send buffer size of the RocketMQ driver client.",template:"Template, the default value is empty. When this value is empty the whole message will be stored in the RocketMQ.<br/>The template can be any valid string with placeholders, example:<br/>- ${'{'}id{'}'}, ${'{'}username{'}'}, ${'{'}clientid{'}'}, ${'{'}timestamp{'}'}<br/>- {'{'}\"id\" : ${'{'}id{'}'}, \"username\" : ${'{'}username{'}'}{'}'}",sync_timeout:"Timeout of RocketMQ driver synchronous call.",namespace:"The namespace field MUST be set if you are using the RocketMQ service in aliyun cloud and also the namespace is enabled, or if you have configured a namespace in your RocketMQ server. For RocketMQ in aliyun cloud, the namespace is the instance ID.",strategy:"Producer key dispatch strategy, the default is `roundrobin`, also supports placeholders."},tdengine:{server:"The IPv4 or IPv6 address or the hostname to connect to.<br/>A host entry has the following form: `Host[:Port]`.<br/>The TDengine default port 6041 is used if `[:Port]` is not specified.",sql:"SQL Template",token:"The token used when connecting to TDengine Cloud. <br/>If this value is provided, it will override the authentication method of Username and Password."},sqlserver:{server:"The IPv4 or IPv6 address or the hostname to connect to.<br/>A host entry has the following form: `Host[:Port]`.<br/>The SQL Server default port 1433 is used if `[:Port]` is not specified.",driver:"SQL Server Driver Name",sql:"SQL Template"},iotdb:{base_url:"The base URL of the external IoTDB service's REST interface.<br/> The URL has the following form `http://Host:Port`.",iotdb_version:"The version of the IoTDB system to connect to.",enable_pipelining:"A positive integer. Whether to send HTTP requests continuously, when set to 1, it means that after each HTTP request is sent, you need to wait for the server to return and then continue to send the next request.",connect_timeout:"The timeout when connecting to the IoTDB server.",timestamp:"Supports the use of ${'{'}var{'}'} format as a placeholder, which should be in timestamp format. You can also use the following special characters to insert system time:<br/>- `now`: Current millisecond-level timestamp<br/>- `now_ms`: Current millisecond-level timestamp<br/>- `now_us`: Current microsecond-level timestamp<br/>- `now_ns`: Current nanosecond-level timestamp",measurement:"Supports the use of ${'{'}var{'}'} format as a placeholder.",data_type:"The data type for the value. Supported types: boolean, int32, int64, float, double, text.",value:"The value to be inserted, supports the use of ${'{'}var{'}'} format as a placeholder.",device_id:"A fixed device name this data should be inserted for. If empty it must either be set in the rule action, the message itself, or it will be extracted from the topic.",is_aligned:"Whether to align the timeseries",recv_timeout:"Timeout for receiving from IoTDB Thrift server."},opents:{server:"The URL of OpenTSDB endpoint.",summary:"Whether to return summary information.",details:"Whether to return detailed information.",timestamp:"Second or millisecond level timestamp, supports placeholders in the format of ${'{'}var{'}'}.",metric:"The name of the metric, should be a unique identifier for the time series data, supports placeholders in the format of ${'{'}var{'}'}.",tags:"Tags for attaching metadata, each tag is a key-value pair, configured in the `key=value,key2=value2` format, and supports placeholders in the format of ${'{'}var{'}'}.",value:"The value of the data point, supports placeholders in the format of ${'{'}var{'}'}. It represents the actual measurement or observed value."},oracle:{server:"The IPv4 or IPv6 address or the hostname to connect to.<br/>A host entry has the following form: `Host[:Port]`.<br/>The Oracle Database default port 1521 is used if `[:Port]` is not specified.",sid:"SID for Oracle Database.",sql:"SQL Template. The template string can contain placeholders for message metadata and payload field. The placeholders are inserted without any checking and special formatting, so it is important to ensure that the inserted values are formatted and escaped correctly."},rabbitmq:{server:"The RabbitMQ server address that you want to connect to (for example, localhost).",port:"The port number on which the RabbitMQ server is listening (default is 5672).",exchange:"The name of the RabbitMQ exchange where the messages will be sent.",routing_key:"The routing key used to route messages to the correct queue in the RabbitMQ exchange.",virtual_host:"The virtual host to use when connecting to the RabbitMQ server.",heartbeat:"The interval for sending heartbeat messages to the RabbitMQ server.",delivery_mode:"The delivery mode for messages published to RabbitMQ. Delivery mode `non_persistent` is suitable for messages that don't require persistence across RabbitMQ restarts, whereas delivery mode `persistent` is designed for messages that must survive RabbitMQ restarts.",wait_for_publish_confirmations:"A boolean value that indicates whether to wait for RabbitMQ to confirm message publication when using publisher confirms.",publish_confirmation_timeout:"The timeout for waiting for RabbitMQ to confirm message publication when using publisher confirms.",timeout:"The timeout for waiting on the connection to be established.",payload_template:"The template for formatting the payload of the message before sending it to RabbitMQ. Template placeholders, such as ${'{'}field1.sub_field{'}'}, will be substituted with the respective field's value. When left empty, the entire input message will be used as the payload, formatted as a JSON text. This behavior is equivalent to specifying ${'{'}.{'}'} as the payload template.",queue:"The queue name of the RabbitMQ.",no_ack:"Whether to use no_ack mode when consuming messages from the RabbitMQ."},pulsar:{servers:"Specify the Pulsar Server URL in the format of <code>scheme://host[:port]</code> for the client to connect to. Multiple servers should be added as a comma-separated list. The supported schemes are <code>pulsar://</code> (default) and <code>pulsar+ssl://</code>. The default port is 6650.",pulsar_topic:"Pulsar topic name",strategy:"Choose how messages are dispatched to Pulsar partitions:<br/><code>random</code>: Messages are randomly assigned to partitions.<br/><code>roundrobin</code>: Messages are evenly distributed across available producers.<br/><code>key_dispatch</code>: Partitions to be selected are hashed and stored in the Pulsar message key of the first message in a batch.",compression:"Compression method.",message_key:"Template to render Pulsar message key.",message_value:"Template to render Pulsar message value.",sync_timeout:"Maximum wait time for receipt in synchronously publishing.",retention_period:"Specify the duration to buffer messages when disconnected from the Pulsar broker. Longer times increase memory/disk usage.",send_buffer:"Fine tune the socket send buffer. The default value is tuned for high throughput.",max_batch_bytes:"Specify the limit on the number of bytes collected in a batch. EMQX has set the default value to less than 5 MB to account for encoding overheads especially when handling small messages. If a single message exceeds the batch size limit, it will still be sent as a single-element batch, indicating it will be treated as a separate batch containing only that specific message.",connect_timeout:"Maximum wait time for TCP connection establishment (including authentication time if enabled).",mode:"Message buffer mode:<br/><code>memory</code>: Buffer all messages in memory. The messages will be lost if EMQX node restarts.<br/><code>disk</code>: Buffer all messages on disk. The messages are designed to persist even during an EMQX node restart.<br/><code>hybrid</code>: Buffer message in memory first, when up to a certain limit (see <code>segment_bytes</code> config for more information), then start offloading messages to disk, the messages will be lost in if EMQX node restarts.",per_partition_limit:"Number of bytes allowed to buffer for each Pulsar partition. When the message limit is exceeded, older messages will be selectively dropped to allocate buffer space for new messages.",segment_bytes:"Applicable when buffer mode is set to <code>disk</code> or <code>hybrid</code>.<br/>This value is to specify the size of each on-disk buffer file.",authentication_jwt:"JWT authentication token.",max_inflight:"The maximum number of message batches that the producer can send to each partition before it must wait for a receipt.<br/>Setting a higher number can enhance throughput."},azure_event_hub_producer:{bootstrap_hosts:"A comma separated list of Azure Event Hubs Kafka <code>host[:port]</code> namespace endpoints to bootstrap the client.  Default port number is 9093.",connect_timeout:"Maximum wait time for TCP connection establishment (including authentication time if enabled).",min_metadata_refresh_interval:"Minimum time interval the client has to wait before refreshing Azure Event Hubs Kafka broker and topic metadata. Setting too small value may add extra load on Azure Event Hubs.",metadata_request_timeout:"Maximum wait time when fetching metadata from Azure Event Hubs.",password:'The Connection String for connecting to Azure Event Hubs. Should be the "connection string-primary key" of a Namespace shared access policy.',topic:"Event Hub name",max_batch_bytes:"Maximum bytes to collect in an Azure Event Hubs message batch. Most of the Kafka brokers default to a limit of 1 MB batch size. EMQX's default value is less than 1 MB in order to compensate Kafka message encoding overheads (especially when each individual message is very small). When a single message is over the limit, it is still sent (as a single element batch).",partition_strategy:`Partition strategy is to tell the producer how to dispatch messages to Azure Event Hubs partitions.
+ The actual number may be less than the specified value.`,connect_timeout:"The timeout when connecting to the GCP server."},hstreamdb:{url:"HStreamDB Server URL. Using gRPC http server address.",partition_key:"HStreamDB Partition Key. Placeholders supported.",grpc_flush_timeout:"Time interval for flushing gRPC calls to the HStreamDB server.",aggregation_pool_size:"The size of the record aggregation pool. A larger aggregation pool size can lead to enhanced parallelization but may also result in reduced efficiency due to smaller batch sizes.",max_batches:"Maximum number of unconfirmed batches in the flush queue.",writer_pool_size:"The size of the writer pool. A larger pool may increase parallelization and concurrent write operations, potentially boosting throughput. Trade-offs include greater memory consumption and possible resource contention.",batch_interval:"Maximum interval that is allowed between two successive (batch) request.",record_template:"The HStream record template to be forwarded to the HStreamDB. Placeholders supported.<br/>NOTE: When you use `raw record` template (which means the data is not a valid JSON), you should use `read` or `subscription` in HStream to get the data.",parameters_batch_size:"Maximum number of insert data clauses that can be sent in a single request."},influxdb:{server:"The IPv4 or IPv6 address or the hostname to connect to.<br/><br/>A host entry has the following form: `Host[:Port]`.<br/><br/>The InfluxDB default port 8086 is used if `[:Port]` is not specified.",token:"InfluxDB token.",org:"Organization name of InfluxDB.",bucket:"InfluxDB bucket name.",write_syntax:"Conf of InfluxDB line protocol to write data points. It is a text-based format that provides the measurement, tag set, field set, and timestamp of a data point, and placeholder supported. See also [InfluxDB 2.3 Line Protocol](https://docs.influxdata.com/influxdb/v2.3/reference/syntax/line-protocol/) and [InfluxDB 1.8 Line Protocol](https://docs.influxdata.com/influxdb/v1.8/write_protocols/line_protocol_tutorial/) <br/>TLDR:<br/>```<measurement>[,<tag_key>=<tag_value>[,<tag_key>=<tag_value>]] <field_key>=<field_value>[,<field_key>=<field_value>] [<timestamp>]```<br/>Please note that a placeholder for an integer value must be annotated with a suffix `i`. For example `${'{'}payload.int_value{'}'}i`.",precision:"InfluxDB time precision."},datalayers:{write_syntax:"Datalayers adopts a line protocol fully compatible with InfluxDB v1, providing users with a familiar and efficient method for data ingestion. While compatible with InfluxDB v1 syntax, Datalayers has its unique characteristics in its underlying implementation to optimize performance and adapt to its specific storage structure. For more information, refer to [InfluxDB Line Protocol](https://docs.datalayers.cn/datalayers/latest/development-guide/writing-with-influxdb-line-protocol.html).",precision:"Datalayers time precision."},confluent_producer:{connect_timeout:"Maximum wait time for TCP connection establishment (including authentication time if enabled).",bootstrap_hosts:"A comma separated list of Kafka <code>host[:port]</code> endpoints to bootstrap the client. Default port number is 9092.",min_metadata_refresh_interval:"Minimum time interval the client has to wait before refreshing Kafka broker and topic metadata. Setting too small value may add extra load on Kafka.",metadata_request_timeout:"Maximum wait time when fetching metadata from Kafka.",topic:"Kafka topic",kafka_headers:`Please provide a placeholder to be used as Kafka Headers<br/>e.g. <code>\${'{'}pub_props{'}'}</code><br/>Notice that the value of the placeholder must either be an object:<br/>\`{'{'}"foo": "bar"{'}'}\`<br/>`,kafka_header_value_encode_mode:"Kafka headers value encode mode:<br/>- `NONE`: only add binary values to Kafka headers;<br/>- `JSON`: only add JSON values to Kafka headers, and encode it to JSON strings before sending.",kafka_ext_headers:"Please provide more key-value pairs for Kafka headers.<br/>The key-value pairs here will be combined with the value of `kafka_headers` field before sending to Kafka.",key:"Template to render Kafka message key. If the template is rendered into a NULL value (i.e. there is no such data field in Rule Engine context) then Kafka's <code>NULL</code> (but not empty string) is used.",value:"Template to render Kafka message value. If the template is rendered into a NULL value (i.e. there is no such data field in Rule Engine context) then Kafka's <code>NULL</code> (but not empty string) is used.",partition_strategy:"Partition strategy is to tell the producer how to dispatch messages to Kafka partitions.<br/><code>random</code>: Randomly pick a partition for each message<br/><code>key_dispatch</code>: Hash Kafka message key to a partition number",max_batch_bytes:"Maximum bytes to collect in a Kafka message batch. Most of the Kafka brokers default to a limit of 1 MB batch size. EMQX's default value is less than 1 MB in order to compensate Kafka message encoding overheads (especially when each individual message is very small). When a single message is over the limit, it is still sent (as a single element batch).",required_acks:"Required acknowledgements for Kafka partition leader to wait for its followers before it sends back the acknowledgement to EMQX Kafka producer<br/><code>all_isr</code>: Require all in-sync replicas to acknowledge.<br/><code>leader_only</code>: Require only the partition-leader's acknowledgement.<br/><code>none</code>: No need for Kafka to acknowledge at all.",partition_count_refresh_interval:"The time interval for Kafka producer to discover increased number of partitions.<br/>After the number of partitions is increased in Kafka, EMQX will start taking the <br/>discovered partitions into account when dispatching messages per <code>partition_strategy</code>.",max_inflight:"Maximum number of batches allowed for Kafka producer (per-partition) to send before receiving acknowledgement from Kafka. Greater value typically means better throughput. However, there can be a risk of message reordering when this value is greater than 1.",query_mode:"Query mode. Optional 'sync/async', default 'async'.",sync_query_timeout:"This parameter defines the timeout limit for synchronous queries. It applies only when the bridge query mode is configured to 'sync'.",mode:"Message buffer mode.<br/><code>memory</code>: Buffer all messages in memory. The messages will be lost in case of EMQX node restart<br/><code>disk</code>: Buffer all messages on disk. The messages on disk are able to survive EMQX node restart.<br/><code>hybrid</code>: Buffer message in memory first, when up to certain limit (see <code>segment_bytes</code> config for more information), then start offloading messages to disk, Like <code>memory</code> mode, the messages will be lost in case of EMQX node restart.",per_partition_limit:"Number of bytes allowed to buffer for each Kafka partition. When this limit is exceeded, old messages will be dropped in a trade for credits for new messages to be buffered.",segment_bytes:"Applicable when buffer mode is set to <code>disk</code> or <code>hybrid</code>.<br/>This value is to specify the size of each on-disk buffer file.",compression:"Compression method.",partitions_limit:"Limits the maximum number of partitions to which a producer can send messages."},kafka_producer:{bootstrap_hosts:"A comma separated list of Kafka <code>host[:port]</code> endpoints to bootstrap the client. Default port number is 9092.",authentication:"Authentication configs.",connect_timeout:"Maximum wait time for TCP connection establishment (including authentication time if enabled).",min_metadata_refresh_interval:"Minimum time interval the client has to wait before refreshing Kafka broker and topic metadata. Setting too small value may add extra load on Kafka.",metadata_request_timeout:"Maximum wait time when fetching metadata from Kafka.",topic:"Kafka topic",kafka_headers:`Please provide a placeholder to be used as Kafka Headers<br/>e.g. <code>\${'{'}pub_props{'}'}</code><br/>Notice that the value of the placeholder must either be an object:<br/>\`{'{'}"foo": "bar"{'}'}\`<br/>`,kafka_header_value_encode_mode:"Kafka headers value encode mode:<br/>- `NONE`: only add binary values to Kafka headers;<br/>- `JSON`: only add JSON values to Kafka headers, and encode it to JSON strings before sending.",kafka_ext_headers:"Please provide more key-value pairs for Kafka headers.<br/>The key-value pairs here will be combined with the value of `kafka_headers` field before sending to Kafka.",key:"Template to render Kafka message key. If the template is rendered into a NULL value (i.e. there is no such data field in Rule Engine context) then Kafka's <code>NULL</code> (but not empty string) is used.",value:"Template to render Kafka message value. If the template is rendered into a NULL value (i.e. there is no such data field in Rule Engine context) then Kafka's <code>NULL</code> (but not empty string) is used.",kafka_message_timestamp:"Which timestamp to use. The timestamp is expected to be a millisecond precision Unix epoch which can be in string format, e.g. <code>1661326462115</code> or <code>'1661326462115'</code>. When the desired data field for this template is not found, or if the found data is not a valid integer, the current system timestamp will be used.",compression:"Compression method.",partition_strategy:"Partition strategy is to tell the producer how to dispatch messages to Kafka partitions.<br/><code>random</code>: Randomly pick a partition for each message<br/><code>key_dispatch</code>: Hash Kafka message key to a partition number",max_batch_bytes:"Maximum bytes to collect in a Kafka message batch. Most of the Kafka brokers default to a limit of 1 MB batch size. EMQX's default value is less than 1 MB in order to compensate Kafka message encoding overheads (especially when each individual message is very small). When a single message is over the limit, it is still sent (as a single element batch).",required_acks:"Required acknowledgements for Kafka partition leader to wait for its followers before it sends back the acknowledgement to EMQX Kafka producer<br/><code>all_isr</code>: Require all in-sync replicas to acknowledge.<br/><code>leader_only</code>: Require only the partition-leader's acknowledgement.<br/><code>none</code>: No need for Kafka to acknowledge at all.",partition_count_refresh_interval:"The time interval for Kafka producer to discover increased number of partitions.<br/>After the number of partitions is increased in Kafka, EMQX will start taking the <br/>discovered partitions into account when dispatching messages per <code>partition_strategy</code>.",max_inflight:"Maximum number of batches allowed for Kafka producer (per-partition) to send before receiving acknowledgement from Kafka. Greater value typically means better throughput. However, there can be a risk of message reordering when this value is greater than 1.",query_mode:"Query mode. Optional 'sync/async', default 'async'.",sync_query_timeout:"This parameter defines the timeout limit for synchronous queries. It applies only when the bridge query mode is configured to 'sync'.",mode:"Message buffer mode.<br/><code>memory</code>: Buffer all messages in memory. The messages will be lost in case of EMQX node restart<br/><code>disk</code>: Buffer all messages on disk. The messages on disk are able to survive EMQX node restart.<br/><code>hybrid</code>: Buffer message in memory first, when up to certain limit (see <code>segment_bytes</code> config for more information), then start offloading messages to disk, Like <code>memory</code> mode, the messages will be lost in case of EMQX node restart.",per_partition_limit:"Number of bytes allowed to buffer for each Kafka partition. When this limit is exceeded, old messages will be dropped in a trade for credits for new messages to be buffered.",segment_bytes:"Applicable when buffer mode is set to <code>disk</code> or <code>hybrid</code>.<br/>This value is to specify the size of each on-disk buffer file.",kafka_ext_header_key:"Key of the Kafka header. Placeholders in the format of <code>${'{'}var{'}'}</code> are supported.",mechanism:"SASL authentication mechanism.",kerberos_principal:"SASL GSSAPI authentication Kerberos principal. For example <code>client_name{'@'}MY.KERBEROS.REALM.MYDOMAIN.COM</code>, NOTE: The realm in use has to be configured in /etc/krb5.conf in EMQX nodes.",kerberos_keytab_file:"SASL GSSAPI authentication Kerberos keytab file path. NOTE: This file has to be placed in EMQX nodes, and the EMQX service runner user requires read permission.",kafka_ext_header_value:"Value of the Kafka header. Placeholders in the format of <code>${'{'}var{'}'}</code> are supported.",partitions_limit:"Limits the maximum number of partitions to which a producer can send messages."},kafka_consumer:{bootstrap_hosts:"A comma separated list of Kafka <code>host[:port]</code> endpoints to bootstrap the client. Default port number is 9092.",key_encoding_mode:"Defines how the key from the Kafka message is encoded before being forwarded via MQTT.<br/><code>none</code> Uses the key from the Kafka message unchanged.  Note: in this case, the key must be a valid UTF-8 string.<br/><code>base64</code> Uses base-64 encoding on the received key.",value_encoding_mode:"Defines how the value from the Kafka message is encoded before being forwarded via MQTT.<br/><code>none</code> Uses the value from the Kafka message unchanged.  Note: in this case, the value must be a valid UTF-8 string.<br/><code>base64</code> Uses base-64 encoding on the received value.",offset_reset_policy:"Defines from which offset a consumer should start fetching when there is no commit history or when the commit history becomes invalid.",min_metadata_refresh_interval:"Minimum time interval the client has to wait before refreshing Kafka broker and topic metadata. Setting too small value may add extra load on Kafka.",metadata_request_timeout:"Maximum wait time when fetching metadata from Kafka.",connect_timeout:"Maximum wait time for TCP connection establishment (including authentication time if enabled).",max_batch_bytes:"Set how many bytes to pull from Kafka in each fetch request.<br/>Messages are fetched in batches by the consumer, and if the first record batch in the first non-empty partition of the fetch is larger than this value, the record batch will still be returned to ensure that the consumer can make progress. As such, this is not an absolute maximum. Set `1` for minimal latency.",offset_commit_interval_seconds:"Defines the time interval between two offset commit requests sent for each consumer group.",topic:"Kafka topic",group_id:"Consumer group identifier to be used for this source. If omitted, one based off the source name will be automatically generated.",max_wait_time:"Maximum amount of time that is waited for the Kafka broker to send a fetch response."},mongodb:{collection:"The collection where data will be stored into",payload_template:"The template for formatting the outgoing messages.  If undefined, rule engine will use JSON format to serialize all visible inputs, such as clientid, topic, payload etc.",auth_source:"Database name associated with the user's credentials.",use_legacy_protocol:"Whether to use MongoDB's legacy protocol for communicating with the database. The default is to attempt to automatically determine if the newer protocol is supported.",srv_record:"Use DNS SRV record.",max_overflow:"The maximum number of additional workers that can be created when all workers in the pool are busy. This helps to manage temporary spikes in workload by allowing more concurrent connections to the MongoDB server.",overflow_ttl:'Period of time before workers that exceed the configured pool size ("overflow") to be terminated.',overflow_check_period:'Period for checking if there are more workers than configured ("overflow").',local_threshold:"The size of the latency window for selecting among multiple suitable MongoDB instances.",connect_timeout:"The duration to attempt a connection before timing out.",socket_timeout:"The duration to attempt to send or to receive on a socket before the attempt times out.",server_selection_timeout:"Specifies how long to block for server selection before throwing an exception.",wait_queue_timeout:"The maximum duration that a worker can wait for a connection to become available.",heartbeat_frequency:"Controls when the driver checks the state of the MongoDB deployment. Specify the interval between checks, counted from the end of the previous check until the beginning of the next one. If the number of connections is increased (which will happen, for example, if you increase the pool size), you may need to increase this period as well to avoid creating too many log entries in the MongoDB log file.",min_heartbeat_frequency:"Controls the minimum amount of time to wait between heartbeats.",server:"The IPv4 or IPv6 address or the hostname to connect to.<br/>A host entry has the following form: `Host[:Port]`.<br/>The MongoDB default port 27017 is used if `[:Port]` is not specified.",w_mode:"Write mode.",servers:"A Node list for Cluster to connect to. The nodes should be separated with commas, such as: `Node[,Node].`<br/>For each Node should be: The IPv4 or IPv6 address or the hostname to connect to.<br/>A host entry has the following form: `Host[:Port]`.<br/>The MongoDB default port 27017 is used if `[:Port]` is not specified.",replica_set_name:"Name of the replica set.",r_mode:"Read mode."},mysql:{server:"The IPv4 or IPv6 address or the hostname to connect to.<br/>A host entry has the following form: `Host[:Port]`.<br/>The MySQL default port 3306 is used if `[:Port]` is not specified.",sql:"SQL Template"},pgsql:{server:"The IPv4 or IPv6 address or the hostname to connect to.<br/>A host entry has the following form: `Host[:Port]`.<br/>The default port 5432 is used if `[:Port]` is not specified.",sql:"SQL Template"},redis:{server:"The IPv4 or IPv6 address or the hostname to connect to.<br/>A host entry has the following form: `Host[:Port]`.<br/>The Redis default port 6379 is used if `[:Port]` is not specified.",servers:"A Node list for Cluster to connect to. The nodes should be separated with commas, such as: `Node[,Node].`<br/>For each Node should be: The IPv4 or IPv6 address or the hostname to connect to.<br/>A host entry has the following form: `Host[:Port]`.<br/>The Redis default port 6379 is used if `[:Port]` is not specified.",sentinel:"Sentinel mode. Must be set to 'sentinel' when Redis server is running in sentinel mode.",command_template:"Redis command template used to export messages. Each list element stands for a command name or its argument.<br/>For example, to push payloads in a Redis list by key `msgs`, the elements should be the following:<br/>`rpush`, `msgs`, `${'{'}payload{'}'}`."},rocketmq:{servers:"The IPv4 or IPv6 address or the hostname to connect to.<br/>A host entry has the following form: `Host[:Port]`.<br/>The RocketMQ default port 9876 is used if `[:Port]` is not specified.",access_key:"RocketMQ server `accessKey`.",secret_key:"RocketMQ server `secretKey`.",security_token:"RocketMQ Server Security Token",topic:"RocketMQ Topic",refresh_interval:"RocketMQ Topic Route Refresh Interval.",send_buffer:"The socket send buffer size of the RocketMQ driver client.",template:"Template, the default value is empty. When this value is empty the whole message will be stored in the RocketMQ.<br/>The template can be any valid string with placeholders, example:<br/>- ${'{'}id{'}'}, ${'{'}username{'}'}, ${'{'}clientid{'}'}, ${'{'}timestamp{'}'}<br/>- {'{'}\"id\" : ${'{'}id{'}'}, \"username\" : ${'{'}username{'}'}{'}'}",sync_timeout:"Timeout of RocketMQ driver synchronous call.",namespace:"The namespace field MUST be set if you are using the RocketMQ service in aliyun cloud and also the namespace is enabled, or if you have configured a namespace in your RocketMQ server. For RocketMQ in aliyun cloud, the namespace is the instance ID.",strategy:"Producer key dispatch strategy, the default is `roundrobin`, also supports placeholders."},tdengine:{server:"The IPv4 or IPv6 address or the hostname to connect to.<br/>A host entry has the following form: `[http[s]://]Host[:Port]`.<br/>The TDengine default port 6041 is used if `[:Port]` is not specified.",sql:"SQL Template",token:"The token used when connecting to TDengine Cloud. <br/>If this value is provided, it will override the authentication method of Username and Password."},sqlserver:{server:"The IPv4 or IPv6 address or the hostname to connect to.<br/>A host entry has the following form: `Host[:Port]`.<br/>The SQL Server default port 1433 is used if `[:Port]` is not specified.",driver:"SQL Server Driver Name",sql:"SQL Template"},iotdb:{base_url:"The base URL of the external IoTDB service's REST interface.<br/> The URL has the following form `http://Host:Port`.",iotdb_version:"The version of the IoTDB system to connect to.",enable_pipelining:"A positive integer. Whether to send HTTP requests continuously, when set to 1, it means that after each HTTP request is sent, you need to wait for the server to return and then continue to send the next request.",connect_timeout:"The timeout when connecting to the IoTDB server.",timestamp:"Supports the use of ${'{'}var{'}'} format as a placeholder, which should be in timestamp format. You can also use the following special characters to insert system time:<br/>- `now`: Current millisecond-level timestamp<br/>- `now_ms`: Current millisecond-level timestamp<br/>- `now_us`: Current microsecond-level timestamp<br/>- `now_ns`: Current nanosecond-level timestamp",measurement:"Supports the use of ${'{'}var{'}'} format as a placeholder.",data_type:"The data type for the value. Supported types: boolean, int32, int64, float, double, text.",value:"The value to be inserted, supports the use of ${'{'}var{'}'} format as a placeholder.",device_id:"A fixed device name this data should be inserted for. If empty it must either be set in the rule action, the message itself, or it will be extracted from the topic.",is_aligned:"Whether to align the timeseries",recv_timeout:"Timeout for receiving from IoTDB Thrift server."},opents:{server:"The URL of OpenTSDB endpoint.",summary:"Whether to return summary information.",details:"Whether to return detailed information.",timestamp:"Second or millisecond level timestamp, supports placeholders in the format of ${'{'}var{'}'}.",metric:"The name of the metric, should be a unique identifier for the time series data, supports placeholders in the format of ${'{'}var{'}'}.",tags:"Tags for attaching metadata, each tag is a key-value pair, configured in the `key=value,key2=value2` format, and supports placeholders in the format of ${'{'}var{'}'}.",value:"The value of the data point, supports placeholders in the format of ${'{'}var{'}'}. It represents the actual measurement or observed value."},oracle:{server:"The IPv4 or IPv6 address or the hostname to connect to.<br/>A host entry has the following form: `Host[:Port]`.<br/>The Oracle Database default port 1521 is used if `[:Port]` is not specified.",sid:"SID for Oracle Database.",sql:"SQL Template. The template string can contain placeholders for message metadata and payload field. The placeholders are inserted without any checking and special formatting, so it is important to ensure that the inserted values are formatted and escaped correctly."},rabbitmq:{server:"The RabbitMQ server address that you want to connect to (for example, localhost).",port:"The port number on which the RabbitMQ server is listening (default is 5672).",exchange:"The name of the RabbitMQ exchange where the messages will be sent.",routing_key:"The routing key used to route messages to the correct queue in the RabbitMQ exchange.",virtual_host:"The virtual host to use when connecting to the RabbitMQ server.",heartbeat:"The interval for sending heartbeat messages to the RabbitMQ server.",delivery_mode:"The delivery mode for messages published to RabbitMQ. Delivery mode `non_persistent` is suitable for messages that don't require persistence across RabbitMQ restarts, whereas delivery mode `persistent` is designed for messages that must survive RabbitMQ restarts.",wait_for_publish_confirmations:"A boolean value that indicates whether to wait for RabbitMQ to confirm message publication when using publisher confirms.",publish_confirmation_timeout:"The timeout for waiting for RabbitMQ to confirm message publication when using publisher confirms.",timeout:"The timeout for waiting on the connection to be established.",payload_template:"The template for formatting the payload of the message before sending it to RabbitMQ. Template placeholders, such as ${'{'}field1.sub_field{'}'}, will be substituted with the respective field's value. When left empty, the entire input message will be used as the payload, formatted as a JSON text. This behavior is equivalent to specifying ${'{'}.{'}'} as the payload template.",queue:"The queue name of the RabbitMQ.",no_ack:"Whether to use no_ack mode when consuming messages from the RabbitMQ."},pulsar:{servers:"Specify the Pulsar Server URL in the format of <code>scheme://host[:port]</code> for the client to connect to. Multiple servers should be added as a comma-separated list. The supported schemes are <code>pulsar://</code> (default) and <code>pulsar+ssl://</code>. The default port is 6650.",pulsar_topic:"Pulsar topic name",strategy:"Choose how messages are dispatched to Pulsar partitions:<br/><code>random</code>: Messages are randomly assigned to partitions.<br/><code>roundrobin</code>: Messages are evenly distributed across available producers.<br/><code>key_dispatch</code>: Partitions to be selected are hashed and stored in the Pulsar message key of the first message in a batch.",compression:"Compression method.",message_key:"Template to render Pulsar message key.",message_value:"Template to render Pulsar message value.",sync_timeout:"Maximum wait time for receipt in synchronously publishing.",retention_period:"Specify the duration to buffer messages when disconnected from the Pulsar broker. Longer times increase memory/disk usage.",send_buffer:"Fine tune the socket send buffer. The default value is tuned for high throughput.",max_batch_bytes:"Specify the limit on the number of bytes collected in a batch. EMQX has set the default value to less than 5 MB to account for encoding overheads especially when handling small messages. If a single message exceeds the batch size limit, it will still be sent as a single-element batch, indicating it will be treated as a separate batch containing only that specific message.",connect_timeout:"Maximum wait time for TCP connection establishment (including authentication time if enabled).",mode:"Message buffer mode:<br/><code>memory</code>: Buffer all messages in memory. The messages will be lost if EMQX node restarts.<br/><code>disk</code>: Buffer all messages on disk. The messages are designed to persist even during an EMQX node restart.<br/><code>hybrid</code>: Buffer message in memory first, when up to a certain limit (see <code>segment_bytes</code> config for more information), then start offloading messages to disk, the messages will be lost in if EMQX node restarts.",per_partition_limit:"Number of bytes allowed to buffer for each Pulsar partition. When the message limit is exceeded, older messages will be selectively dropped to allocate buffer space for new messages.",segment_bytes:"Applicable when buffer mode is set to <code>disk</code> or <code>hybrid</code>.<br/>This value is to specify the size of each on-disk buffer file.",authentication_jwt:"JWT authentication token.",max_inflight:"The maximum number of message batches that the producer can send to each partition before it must wait for a receipt.<br/>Setting a higher number can enhance throughput."},azure_event_hub_producer:{bootstrap_hosts:"A comma separated list of Azure Event Hubs Kafka <code>host[:port]</code> namespace endpoints to bootstrap the client.  Default port number is 9093.",connect_timeout:"Maximum wait time for TCP connection establishment (including authentication time if enabled).",min_metadata_refresh_interval:"Minimum time interval the client has to wait before refreshing Azure Event Hubs Kafka broker and topic metadata. Setting too small value may add extra load on Azure Event Hubs.",metadata_request_timeout:"Maximum wait time when fetching metadata from Azure Event Hubs.",password:'The Connection String for connecting to Azure Event Hubs. Should be the "connection string-primary key" of a Namespace shared access policy.',topic:"Event Hub name",max_batch_bytes:"Maximum bytes to collect in an Azure Event Hubs message batch. Most of the Kafka brokers default to a limit of 1 MB batch size. EMQX's default value is less than 1 MB in order to compensate Kafka message encoding overheads (especially when each individual message is very small). When a single message is over the limit, it is still sent (as a single element batch).",partition_strategy:`Partition strategy is to tell the producer how to dispatch messages to Azure Event Hubs partitions.
 
 <code>random</code>: Randomly pick a partition for each message
 <code>key_dispatch</code>: Hash Azure Event Hubs message key to a partition number`,required_acks:`Required acknowledgements for Azure Event Hubs partition leader to wait for its followers before it sends back the acknowledgement to EMQX Azure Event Hubs producer

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emqx/shared-ui-i18n",
-  "version": "0.0.40",
+  "version": "0.0.41",
   "homepage": "https://emqx.io",
   "license": "Apache-2.0",
   "repository": {