emqx_gateway_schema {

dtls_listener_acceptors.desc:
"""Size of the acceptor pool."""

dtls_listener_dtls_opts.desc:
"""DTLS socket options"""

gateway_common_authentication.desc:
"""Default authentication configs for all the gateway listeners. For per-listener overrides see <code>authentication</code>
 in listener configs"""

gateway_common_clientinfo_override.desc:
"""ClientInfo override."""

gateway_common_clientinfo_override_clientid.desc:
"""Template for overriding clientid."""

gateway_common_clientinfo_override_password.desc:
"""Template for overriding password."""

gateway_common_clientinfo_override_username.desc:
"""Template for overriding username."""

gateway_common_enable.desc:
"""Whether to enable this gateway"""

gateway_common_enable_stats.desc:
"""Whether to enable client process statistic"""

gateway_common_idle_timeout.desc:
"""The idle time of the client connection process. It has two purposes:
  1. A newly created client process that does not receive any client requests after that time will be closed directly.
  2. A running client process that does not receive any client requests after this time will go into hibernation to save resources."""

gateway_common_listener_access_rules.desc:
"""An access rule list consisting of string rules to restrict or allow access from some addresses.
The rules that appear earlier in the list are matched first.
The format is `allow | deny <address> | <CIDR> | all`.

For example:

`[\"deny 192.168.1.1\", \"allow 192.168.1.0/24\", \"deny, all\"]`"""

gateway_common_listener_bind.desc:
"""The IP address and port that the listener will bind."""

gateway_common_listener_enable.desc:
"""Enable the listener."""

gateway_common_listener_enable_authn.desc:
"""Set <code>true</code> (default) to enable client authentication on this listener.
When set to <code>false</code> clients will be allowed to connect without authentication."""

gateway_common_listener_max_conn_rate.desc:
"""Maximum connections per second."""

gateway_common_listener_max_connections.desc:
"""The maximum number of concurrent connections allowed by the listener."""

gateway_mountpoint.desc:
"""When publishing or subscribing, prefix all topics with a mountpoint string.
The prefixed string will be removed from the topic name when the message is delivered to the subscriber.
The mountpoint is a way that users can use to implement isolation of message routing between different listeners.
For example if a client A subscribes to `t` with `listeners.tcp.\<name>.mountpoint` set to `some_tenant`,
then the client actually subscribes to the topic `some_tenant/t`.
Similarly, if another client B (connected to the same listener as the client A) sends a message to topic `t`,
the message is routed to all the clients subscribed `some_tenant/t`,
so client A will receive the message, with topic name `t`. Set to `""` to disable the feature.
Supported placeholders in mountpoint string:<br/>
  - <code>${clientid}</code>: clientid<br/>
  - <code>${username}</code>: username<br/>
  - <code>${endpoint_name}</code>: endpoint name"""

listener_name_to_settings_map.desc:
"""A map from listener names to listener settings."""

ssl_listener_options.desc:
"""SSL Socket options."""

tcp_listener_acceptors.desc:
"""Size of the acceptor pool."""

tcp_listener_proxy_protocol.desc:
"""If a reverse proxy is deployed for EMQX, and the PROXY protocol is enabled at the proxy to pass the client's real IP,
this option needs to be turned on so that EMQX can extract the client's real IP from the PROXY protocol header.
EMQX will automatically detect the version of the PROXY protocol and support V1 and V2.

For a detailed description of the PROXY protocol, please refer to: https://www.haproxy.com/blog/haproxy/proxy-protocol/"""

tcp_listener_proxy_protocol_timeout.desc:
"""Timeout for proxy protocol.
EMQX will close the TCP connection if proxy protocol packet is not received within the timeout."""

tcp_listener_tcp_opts.desc:
"""Setting the TCP socket options."""

tcp_listeners.desc:
"""Settings for the TCP listeners."""

tcp_udp_listeners.desc:
"""Settings for the listeners."""

udp_listener_active_n.desc:
"""Specify the {active, N} option for the socket.
See: https://erlang.org/doc/man/inet.html#setopts-2"""

udp_listener_buffer.desc:
"""Size of the user-space buffer for the socket."""

udp_listener_recbuf.desc:
"""Size of the kernel-space receive buffer for the socket."""

udp_listener_reuseaddr.desc:
"""Allow local reuse of port numbers."""

udp_listener_sndbuf.desc:
"""Size of the kernel-space send buffer for the socket."""

udp_listener_udp_opts.desc:
"""Settings for the UDP sockets."""

udp_listeners.desc:
"""Settings for the UDP listeners."""

fields_ws_opts_path.desc:
"""WebSocket's MQTT protocol path. So the address of EMQX Broker's WebSocket is:
<code>ws://{ip}:{port}/mqtt</code>"""

fields_ws_opts_path.label:
"""WS MQTT Path"""

fields_ws_opts_piggyback.desc:
"""Whether a WebSocket message is allowed to contain multiple MQTT packets."""

fields_ws_opts_piggyback.label:
"""MQTT Piggyback"""

fields_ws_opts_compress.desc:
"""If <code>true</code>, compress WebSocket messages using <code>zlib</code>.<br/>
The configuration items under <code>deflate_opts</code> belong to the compression-related parameter configuration."""

fields_ws_opts_compress.label:
"""Ws compress"""

fields_ws_opts_idle_timeout.desc:
"""The timeout for waiting for the WebSocket upgrade request. After the timeout, the connection will be closed."""

fields_ws_opts_idle_timeout.label:
"""WebSocket Upgrade Timeout"""

fields_ws_opts_max_frame_size.desc:
"""The maximum length of a single MQTT packet."""

fields_ws_opts_max_frame_size.label:
"""Max frame size"""

fields_ws_opts_fail_if_no_subprotocol.desc:
"""If <code>true</code>, the server will return an error when
 the client does not carry the <code>Sec-WebSocket-Protocol</code> field.
 <br/>Note: WeChat applet needs to disable this verification."""

fields_ws_opts_fail_if_no_subprotocol.label:
"""Fail if no subprotocol"""

fields_ws_opts_supported_subprotocols.desc:
"""Comma-separated list of supported subprotocols."""

fields_ws_opts_supported_subprotocols.label:
"""Supported subprotocols"""

fields_ws_opts_check_origin_enable.desc:
"""If <code>true</code>, <code>origin</code> HTTP header will be
 validated against the list of allowed origins configured in <code>check_origins</code>
 parameter."""

fields_ws_opts_check_origin_enable.label:
"""Check origin"""

fields_ws_opts_allow_origin_absence.desc:
"""If <code>false</code> and <code>check_origin_enable</code> is
 <code>true</code>, the server will reject requests that don't have <code>origin</code>
 HTTP header."""

fields_ws_opts_allow_origin_absence.label:
"""Allow origin absence"""

fields_ws_opts_check_origins.desc:
"""List of allowed origins.<br/>See <code>check_origin_enable</code>."""

fields_ws_opts_check_origins.label:
"""Allowed origins"""
fields_ws_opts_proxy_port_header.desc:
"""HTTP header used to pass information about the client port. Relevant when the EMQX cluster is deployed behind a load-balancer."""

fields_ws_opts_proxy_port_header.label:
"""Proxy port header"""

fields_ws_opts_proxy_address_header.desc:
"""HTTP header used to pass information about the client IP address.
Relevant when the EMQX cluster is deployed behind a load-balancer."""

fields_ws_opts_proxy_address_header.label:
"""Proxy address header"""

udp_health_check.desc:
"""Some Cloud platform use a `request-reply` mechanism to check whether a UDP port is healthy, here can configure this pair."""

udp_health_check_request.desc:
"""The content of the request."""

udp_health_check_reply.desc:
"""The content to reply."""

}