all-config-meta.json

[
    {
        "module": "io.helidon.webclient.http1",
        "types": [
            {
                "annotatedType": "io.helidon.webclient.http1.Http1ClientProtocolConfig",
                "type": "io.helidon.webclient.http1.Http1ClientProtocolConfig",
                "producers": [
                    "io.helidon.webclient.http1.Http1ClientProtocolConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.webclient.http1.Http1ClientProtocolConfig#builder()"
                ],
                "options": [
                    {
                        "defaultValue": "true",
                        "description": "Sets whether the response header format is validated or not.\n <p>\n     Defaults to `true`.\n </p>\n\n @return whether response header validation should be enabled",
                        "key": "validate-response-headers",
                        "method": "io.helidon.webclient.http1.Http1ClientProtocolConfig.Builder#validateResponseHeaders(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "256",
                        "description": "Configure the maximum allowed length of the status line from the response.\n\n @return maximum status line length",
                        "key": "max-status-line-length",
                        "method": "io.helidon.webclient.http1.Http1ClientProtocolConfig.Builder#maxStatusLineLength(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "false",
                        "description": "Sets whether the request header format is validated or not.\n <p>\n     Defaults to `false` as user has control on the header creation.\n </p>\n\n @return whether request header validation should be enabled",
                        "key": "validate-request-headers",
                        "method": "io.helidon.webclient.http1.Http1ClientProtocolConfig.Builder#validateRequestHeaders(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "http_1_1",
                        "description": "",
                        "key": "name",
                        "method": "io.helidon.webclient.http1.Http1ClientProtocolConfig.Builder#name(java.lang.String)"
                    },
                    {
                        "defaultValue": "16384",
                        "description": "Configure the maximum allowed header size of the response.\n\n @return  maximum header size",
                        "key": "max-header-size",
                        "method": "io.helidon.webclient.http1.Http1ClientProtocolConfig.Builder#maxHeaderSize(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether to use keep alive by default.\n\n @return `true` for keeping connections alive and re-using them for multiple requests (default), `false`\n  to create a new connection for each request",
                        "key": "default-keep-alive",
                        "method": "io.helidon.webclient.http1.Http1ClientProtocolConfig.Builder#defaultKeepAlive(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.webclient.websocket",
        "types": [
            {
                "annotatedType": "io.helidon.webclient.websocket.WsClientProtocolConfig",
                "type": "io.helidon.webclient.websocket.WsClientProtocolConfig",
                "producers": [
                    "io.helidon.webclient.websocket.WsClientProtocolConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.webclient.websocket.WsClientProtocolConfig#builder()"
                ],
                "options": [
                    {
                        "description": "",
                        "key": "sub-protocols",
                        "kind": "LIST",
                        "method": "io.helidon.webclient.websocket.WsClientProtocolConfig.Builder#subProtocols(java.util.List<java.lang.String>)"
                    },
                    {
                        "defaultValue": "websocket",
                        "description": "",
                        "key": "name",
                        "method": "io.helidon.webclient.websocket.WsClientProtocolConfig.Builder#name(java.lang.String)"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.webclient.websocket.WsClientConfig",
                "type": "io.helidon.webclient.websocket.WsClient",
                "producers": [
                    "io.helidon.webclient.websocket.WsClientConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.webclient.websocket.WsClientConfig#builder()",
                    "io.helidon.webclient.websocket.WsClient#create(io.helidon.webclient.websocket.WsClientConfig)"
                ],
                "options": [
                    {
                        "defaultValue": "create()",
                        "description": "WebSocket specific configuration.\n\n @return protocol specific configuration",
                        "key": "protocol-config",
                        "method": "io.helidon.webclient.websocket.WsClientConfig.Builder#protocolConfig(io.helidon.webclient.websocket.WsClientProtocolConfig)",
                        "type": "io.helidon.webclient.websocket.WsClientProtocolConfig"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.webclient.http2",
        "types": [
            {
                "annotatedType": "io.helidon.webclient.http2.Http2ClientProtocolConfig",
                "type": "io.helidon.webclient.http2.Http2ClientProtocolConfig",
                "producers": [
                    "io.helidon.webclient.http2.Http2ClientProtocolConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.webclient.http2.Http2ClientProtocolConfig#builder()"
                ],
                "options": [
                    {
                        "defaultValue": "false",
                        "description": "Prior knowledge of HTTP/2 capabilities of the server. If server we are connecting to does not\n support HTTP/2 and prior knowledge is set to `false`, only features supported by HTTP/1 will be available\n and attempts to use HTTP/2 specific will throw an UnsupportedOperationException.\n <h4>Plain text connection</h4>\n If prior knowledge is set to `true`, we will not attempt an upgrade of connection and use prior knowledge.\n If prior knowledge is set to `false`, we will initiate an HTTP/1 connection and upgrade it to HTTP/2,\n if supported by the server.\n plaintext connection (`h2c`).\n <h4>TLS protected connection</h4>\n If prior knowledge is set to `true`, we will negotiate protocol using HTTP/2 only, failing if not supported.\n if prior knowledge is set to `false`, we will negotiate protocol using both HTTP/2 and HTTP/1, using the protocol\n supported by server.\n\n @return whether to use prior knowledge of HTTP/2",
                        "key": "prior-knowledge",
                        "method": "io.helidon.webclient.http2.Http2ClientProtocolConfig.Builder#priorKnowledge(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "PT0.1S",
                        "description": "Timeout for blocking between windows size check iterations.\n\n @return timeout",
                        "key": "flow-control-block-timeout",
                        "method": "io.helidon.webclient.http2.Http2ClientProtocolConfig.Builder#flowControlBlockTimeout(java.time.Duration)",
                        "type": "java.time.Duration"
                    },
                    {
                        "defaultValue": "PT0.5S",
                        "description": "Timeout for ping probe used for checking healthiness of cached connections.\n Defaults to `PT0.5S`, which means 500 milliseconds.\n\n @return timeout",
                        "key": "ping-timeout",
                        "method": "io.helidon.webclient.http2.Http2ClientProtocolConfig.Builder#pingTimeout(java.time.Duration)",
                        "type": "java.time.Duration"
                    },
                    {
                        "defaultValue": "16384",
                        "description": "Configure initial MAX_FRAME_SIZE setting for new HTTP/2 connections.\n Maximum size of data frames in bytes the client is prepared to accept from the server.\n Default value is 2^14(16_384).\n\n @return data frame size in bytes between 2^14(16_384) and 2^24-1(16_777_215)",
                        "key": "max-frame-size",
                        "method": "io.helidon.webclient.http2.Http2ClientProtocolConfig.Builder#maxFrameSize(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "false",
                        "description": "Check healthiness of cached connections with HTTP/2.0 ping frame.\n Defaults to `false`.\n\n @return use ping if true",
                        "key": "ping",
                        "method": "io.helidon.webclient.http2.Http2ClientProtocolConfig.Builder#ping(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "-1",
                        "description": "Configure initial MAX_HEADER_LIST_SIZE setting for new HTTP/2 connections.\n Sends to the server the maximum header field section size client is prepared to accept.\n Defaults to `-1`, which means \"unconfigured\".\n\n @return units of octets",
                        "key": "max-header-list-size",
                        "method": "io.helidon.webclient.http2.Http2ClientProtocolConfig.Builder#maxHeaderListSize(long)",
                        "type": "java.lang.Long"
                    },
                    {
                        "defaultValue": "h2",
                        "description": "",
                        "key": "name",
                        "method": "io.helidon.webclient.http2.Http2ClientProtocolConfig.Builder#name(java.lang.String)"
                    },
                    {
                        "defaultValue": "65535",
                        "description": "Configure INITIAL_WINDOW_SIZE setting for new HTTP/2 connections.\n Sends to the server the size of the largest frame payload client is willing to receive.\n Defaults to {@value io.helidon.http.http2.WindowSize#DEFAULT_WIN_SIZE}.\n\n @return units of octets",
                        "key": "initial-window-size",
                        "method": "io.helidon.webclient.http2.Http2ClientProtocolConfig.Builder#initialWindowSize(int)",
                        "type": "java.lang.Integer"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.webclient.api",
        "types": [
            {
                "annotatedType": "io.helidon.webclient.api.WebClientConfig",
                "prefix": "clients",
                "type": "io.helidon.webclient.api.WebClient",
                "standalone": true,
                "inherits": [
                    "io.helidon.webclient.api.HttpClientConfig"
                ],
                "producers": [
                    "io.helidon.webclient.api.WebClientConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.webclient.api.WebClientConfig#builder()",
                    "io.helidon.webclient.api.WebClient#create(io.helidon.webclient.api.WebClientConfig)"
                ],
                "options": [
                    {
                        "description": "Configuration of client protocols.\n\n @return client protocol configurations",
                        "key": "protocol-configs",
                        "kind": "LIST",
                        "method": "io.helidon.webclient.api.WebClientConfig.Builder#protocolConfigs(java.util.List<io.helidon.webclient.spi.ProtocolConfig>)",
                        "providerType": "io.helidon.webclient.spi.ProtocolConfigProvider",
                        "type": "io.helidon.webclient.spi.ProtocolConfig",
                        "provider": true
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.webclient.api.HttpClientConfig",
                "type": "io.helidon.webclient.api.HttpClientConfig",
                "inherits": [
                    "io.helidon.webclient.api.HttpConfigBase"
                ],
                "producers": [
                    "io.helidon.webclient.api.HttpClientConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.webclient.api.HttpClientConfig#builder()"
                ],
                "options": [
                    {
                        "defaultValue": "false",
                        "description": "Can be set to `true` to force the use of relative URIs in all requests,\n regardless of the presence or absence of proxies or no-proxy lists.\n\n @return relative URIs flag",
                        "key": "relative-uris",
                        "method": "io.helidon.webclient.api.HttpClientConfig.Builder#relativeUris(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Default headers to be used in every request from configuration.\n\n @return default headers",
                        "key": "default-headers",
                        "kind": "MAP",
                        "method": "io.helidon.webclient.api.HttpClientConfig.Builder#defaultHeadersMap(java.util.Map<java.lang.String, java.lang.String>)"
                    },
                    {
                        "description": "Configure the listener specific io.helidon.http.encoding.ContentEncodingContext.\n This method discards all previously registered ContentEncodingContext.\n If no content encoding context is registered, default encoding context is used.\n\n @return content encoding context",
                        "key": "content-encoding",
                        "method": "io.helidon.webclient.api.HttpClientConfig.Builder#contentEncoding(io.helidon.http.encoding.ContentEncodingContext)",
                        "type": "io.helidon.http.encoding.ContentEncodingContext"
                    },
                    {
                        "defaultValue": "256",
                        "description": "Maximal size of the connection cache.\n For most HTTP protocols, we may cache connections to various endpoints for keep alive (or stream reuse in case of HTTP/2).\n This option limits the size. Setting this number lower than the \"usual\" number of target services will cause connections\n to be closed and reopened frequently.",
                        "key": "connection-cache-size",
                        "method": "io.helidon.webclient.api.HttpClientConfig.Builder#connectionCacheSize(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "description": "WebClient services.\n\n @return services to use with this web client",
                        "key": "services",
                        "kind": "LIST",
                        "method": "io.helidon.webclient.api.HttpClientConfig.Builder#services(java.util.List<io.helidon.webclient.spi.WebClientService>)",
                        "providerType": "io.helidon.webclient.spi.WebClientServiceProvider",
                        "type": "io.helidon.webclient.spi.WebClientService",
                        "provider": true
                    },
                    {
                        "defaultValue": "create()",
                        "description": "Configure the listener specific io.helidon.http.media.MediaContext.\n This method discards all previously registered MediaContext.\n If no media context is registered, default media context is used.\n\n @return media context",
                        "key": "media-context",
                        "method": "io.helidon.webclient.api.HttpClientConfig.Builder#mediaContext(io.helidon.http.media.MediaContext)",
                        "type": "io.helidon.http.media.MediaContext"
                    },
                    {
                        "description": "WebClient cookie manager.\n\n @return cookie manager to use",
                        "key": "cookie-manager",
                        "method": "io.helidon.webclient.api.HttpClientConfig.Builder#cookieManager(java.util.Optional<io.helidon.webclient.api.WebClientCookieManager>)",
                        "type": "io.helidon.webclient.api.WebClientCookieManager"
                    },
                    {
                        "defaultValue": "131072",
                        "description": "If the entity is expected to be smaller that this number of bytes, it would be buffered in memory to optimize performance.\n If bigger, streaming will be used.\n <p>\n Note that for some entity types we cannot use streaming, as they are already fully in memory (String, byte[]), for such\n cases, this option is ignored. Default is 128Kb.\n\n @return maximal number of bytes to buffer in memory for supported writers",
                        "key": "max-in-memory-entity",
                        "method": "io.helidon.webclient.api.HttpClientConfig.Builder#maxInMemoryEntity(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether Expect-100-Continue header is sent to verify server availability before sending an entity.\n <p>\n Defaults to `true`.\n </p>\n\n @return whether Expect:100-Continue header should be sent on streamed transfers",
                        "key": "send-expect-continue",
                        "method": "io.helidon.webclient.api.HttpClientConfig.Builder#sendExpectContinue(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Socket options for connections opened by this client.\n If there is a value explicitly configured on this type and on the socket options,\n the one configured on this type's builder will win:\n <ul>\n     <li>#readTimeout()</li>\n     <li>#connectTimeout()</li>\n </ul>\n\n @return socket options",
                        "key": "socket-options",
                        "method": "io.helidon.webclient.api.HttpClientConfig.Builder#socketOptions(io.helidon.common.socket.SocketOptions)",
                        "type": "io.helidon.common.socket.SocketOptions"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether to share connection cache between all the WebClient instances in JVM.\n\n @return true if connection cache is shared",
                        "key": "share-connection-cache",
                        "method": "io.helidon.webclient.api.HttpClientConfig.Builder#shareConnectionCache(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "STRICT",
                        "description": "Configure media type parsing mode for HTTP `Content-Type` header.\n\n @return media type parsing mode",
                        "key": "media-type-parser-mode",
                        "method": "io.helidon.webclient.api.HttpClientConfig.Builder#mediaTypeParserMode(io.helidon.common.media.type.ParserMode)",
                        "type": "io.helidon.common.media.type.ParserMode",
                        "allowedValues": [
                            {
                                "description": "",
                                "value": "STRICT"
                            },
                            {
                                "description": "",
                                "value": "RELAXED"
                            }
                        ]
                    },
                    {
                        "description": "Base uri used by the client in all requests.\n\n @return base uri of the client requests",
                        "key": "base-uri",
                        "method": "io.helidon.webclient.api.HttpClientConfig.Builder#baseUri(java.util.Optional<io.helidon.webclient.api.ClientUri>)",
                        "type": "io.helidon.webclient.api.ClientUri"
                    },
                    {
                        "defaultValue": "PT1S",
                        "description": "Socket 100-Continue read timeout. Default is 1 second.\n This read timeout is used when 100-Continue is sent by the client, before it sends an entity.\n\n @return read 100-Continue timeout duration",
                        "key": "read-continue-timeout",
                        "method": "io.helidon.webclient.api.HttpClientConfig.Builder#readContinueTimeout(java.time.Duration)",
                        "type": "java.time.Duration"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.webclient.api.WebClientCookieManagerConfig",
                "type": "io.helidon.webclient.api.WebClientCookieManager",
                "producers": [
                    "io.helidon.webclient.api.WebClientCookieManagerConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.webclient.api.WebClientCookieManagerConfig#builder()",
                    "io.helidon.webclient.api.WebClientCookieManager#create(io.helidon.webclient.api.WebClientCookieManagerConfig)"
                ],
                "options": [
                    {
                        "defaultValue": "false",
                        "description": "Whether automatic cookie store is enabled or not.\n\n @return status of cookie store",
                        "key": "automatic-store-enabled",
                        "method": "io.helidon.webclient.api.WebClientCookieManagerConfig.Builder#automaticStoreEnabled(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "java.net.CookiePolicy.ACCEPT_ORIGINAL_SERVER",
                        "description": "Current cookie policy for this client.\n\n @return the cookie policy",
                        "key": "cookie-policy",
                        "method": "io.helidon.webclient.api.WebClientCookieManagerConfig.Builder#cookiePolicy(java.net.CookiePolicy)",
                        "type": "java.net.CookiePolicy"
                    },
                    {
                        "description": "Map of default cookies to include in all requests if cookies enabled.\n\n @return map of default cookies",
                        "key": "default-cookies",
                        "kind": "MAP",
                        "method": "io.helidon.webclient.api.WebClientCookieManagerConfig.Builder#defaultCookies(java.util.Map<java.lang.String, java.lang.String>)"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.webclient.api.HttpConfigBase",
                "type": "io.helidon.webclient.api.HttpConfigBase",
                "producers": [
                    "io.helidon.webclient.api.HttpConfigBase#create(io.helidon.common.config.Config)",
                    "io.helidon.webclient.api.HttpConfigBase#builder()"
                ],
                "options": [
                    {
                        "description": "Read timeout.\n\n @return read timeout\n @see io.helidon.common.socket.SocketOptions#readTimeout()",
                        "key": "read-timeout",
                        "method": "io.helidon.webclient.api.HttpConfigBase.Builder#readTimeout(java.util.Optional<java.time.Duration>)",
                        "type": "java.time.Duration"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Determines if connection keep alive is enabled (NOT socket keep alive, but HTTP connection keep alive, to re-use\n the same connection for multiple requests).\n\n @return keep alive for this connection\n @see io.helidon.common.socket.SocketOptions#socketKeepAlive()",
                        "key": "keep-alive",
                        "method": "io.helidon.webclient.api.HttpConfigBase.Builder#keepAlive(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Proxy configuration to be used for requests.\n\n @return proxy to use, defaults to Proxy#noProxy()",
                        "key": "proxy",
                        "method": "io.helidon.webclient.api.HttpConfigBase.Builder#proxy(io.helidon.webclient.api.Proxy)",
                        "type": "io.helidon.webclient.api.Proxy"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether to follow redirects.\n\n @return whether to follow redirects",
                        "key": "follow-redirects",
                        "method": "io.helidon.webclient.api.HttpConfigBase.Builder#followRedirects(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Connect timeout.\n\n @return connect timeout\n @see io.helidon.common.socket.SocketOptions#connectTimeout()",
                        "key": "connect-timeout",
                        "method": "io.helidon.webclient.api.HttpConfigBase.Builder#connectTimeout(java.util.Optional<java.time.Duration>)",
                        "type": "java.time.Duration"
                    },
                    {
                        "defaultValue": "10",
                        "description": "Max number of followed redirects.\n This is ignored if #followRedirects() option is `false`.\n\n @return max number of followed redirects",
                        "key": "max-redirects",
                        "method": "io.helidon.webclient.api.HttpConfigBase.Builder#maxRedirects(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "description": "TLS configuration for any TLS request from this client.\n TLS can also be configured per request.\n TLS is used when the protocol is set to `https`.\n\n @return TLS configuration to use",
                        "key": "tls",
                        "method": "io.helidon.webclient.api.HttpConfigBase.Builder#tls(io.helidon.common.tls.Tls)",
                        "type": "io.helidon.common.tls.Tls"
                    },
                    {
                        "description": "Properties configured for this client. These properties are propagated through client request, to be used by\n services (and possibly for other purposes).\n\n @return map of client properties",
                        "key": "properties",
                        "kind": "MAP",
                        "method": "io.helidon.webclient.api.HttpConfigBase.Builder#properties(java.util.Map<java.lang.String, java.lang.String>)"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.webclient.api.Proxy.Builder",
                "type": "io.helidon.webclient.api.Proxy",
                "producers": [
                    "io.helidon.webclient.api.Proxy.Builder#build()",
                    "io.helidon.webclient.api.Proxy#create(io.helidon.common.config.Config)"
                ],
                "options": [
                    {
                        "description": "Sets a new password for the proxy.",
                        "key": "password",
                        "method": "io.helidon.webclient.api.Proxy.Builder#password(char[])"
                    },
                    {
                        "description": "Sets a port value.",
                        "key": "port",
                        "method": "io.helidon.webclient.api.Proxy.Builder#port(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "description": "Sets a new host value.",
                        "key": "host",
                        "method": "io.helidon.webclient.api.Proxy.Builder#host(java.lang.String)"
                    },
                    {
                        "description": "Sets a new username for the proxy.",
                        "key": "username",
                        "method": "io.helidon.webclient.api.Proxy.Builder#username(java.lang.String)"
                    },
                    {
                        "defaultValue": "HTTP",
                        "description": "Sets a new proxy type.",
                        "key": "type",
                        "method": "io.helidon.webclient.api.Proxy.Builder#type(io.helidon.webclient.api.Proxy.ProxyType)",
                        "type": "io.helidon.webclient.api.Proxy.ProxyType",
                        "allowedValues": [
                            {
                                "description": "No proxy.",
                                "value": "NONE"
                            },
                            {
                                "description": "Proxy obtained from system.",
                                "value": "SYSTEM"
                            },
                            {
                                "description": "HTTP proxy.",
                                "value": "HTTP"
                            }
                        ]
                    },
                    {
                        "description": "Configure a host pattern that is not going through a proxy.\n <p>\n Options are:\n <ul>\n     <li>IP Address, such as `192.168.1.1`</li>\n     <li>IP V6 Address, such as `[2001:db8:85a3:8d3:1319:8a2e:370:7348]`</li>\n     <li>Hostname, such as `localhost`</li>\n     <li>Domain name, such as `helidon.io`</li>\n     <li>Domain name and all sub-domains, such as `.helidon.io` (leading dot)</li>\n     <li>Combination of all options from above with a port, such as `.helidon.io:80`</li>\n </ul>",
                        "key": "no-proxy",
                        "kind": "LIST",
                        "method": "io.helidon.webclient.api.Proxy.Builder#addNoProxy(java.lang.String)"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.metrics.api",
        "types": [
            {
                "annotatedType": "io.helidon.metrics.api.KeyPerformanceIndicatorMetricsConfig",
                "type": "io.helidon.metrics.api.KeyPerformanceIndicatorMetricsConfig",
                "producers": [
                    "io.helidon.metrics.api.KeyPerformanceIndicatorMetricsConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.metrics.api.KeyPerformanceIndicatorMetricsConfig#builder()"
                ],
                "options": [
                    {
                        "defaultValue": "PT10S",
                        "description": "Threshold in ms that characterizes whether a request is long running.\n\n @return threshold in ms indicating a long-running request",
                        "key": "long-running-requests.threshold",
                        "method": "io.helidon.metrics.api.KeyPerformanceIndicatorMetricsConfig.Builder#longRunningRequestThreshold(java.time.Duration)",
                        "type": "java.time.Duration"
                    },
                    {
                        "defaultValue": "false",
                        "description": "Whether KPI extended metrics are enabled.\n\n @return true if KPI extended metrics are enabled; false otherwise",
                        "key": "extended",
                        "method": "io.helidon.metrics.api.KeyPerformanceIndicatorMetricsConfig.Builder#extended(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.metrics.api.ScopingConfig",
                "type": "io.helidon.metrics.api.ScopingConfig",
                "producers": [
                    "io.helidon.metrics.api.ScopingConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.metrics.api.ScopingConfig#builder()"
                ],
                "options": [
                    {
                        "defaultValue": "application",
                        "description": "Default scope value to associate with meters that are registered without an explicit setting; no setting means meters\n are assigned scope {@value io.helidon.metrics.api.Meter.Scope#DEFAULT}.\n\n @return default scope value",
                        "key": "default",
                        "method": "io.helidon.metrics.api.ScopingConfig.Builder#defaultValue(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "defaultValue": "scope",
                        "description": "Tag name for storing meter scope values in the underlying implementation meter registry.\n\n @return tag name for storing scope values",
                        "key": "tag-name",
                        "method": "io.helidon.metrics.api.ScopingConfig.Builder#tagName(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "description": "Settings for individual scopes.\n\n @return scope settings",
                        "key": "scopes",
                        "kind": "MAP",
                        "method": "io.helidon.metrics.api.ScopingConfig.Builder#scopes(java.util.Map<java.lang.String, io.helidon.metrics.api.ScopeConfig>)",
                        "type": "io.helidon.metrics.api.ScopeConfig"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.metrics.api.MetricsConfig",
                "prefix": "metrics",
                "type": "io.helidon.metrics.api.MetricsConfig",
                "standalone": true,
                "producers": [
                    "io.helidon.metrics.api.MetricsConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.metrics.api.MetricsConfig#builder()"
                ],
                "options": [
                    {
                        "description": "Whether automatic REST request metrics should be measured.\n\n @return true/false",
                        "key": "rest-request-enabled",
                        "method": "io.helidon.metrics.api.MetricsConfig.Builder#restRequestEnabled(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Name for the application tag to be added to each meter ID.\n\n @return application tag name",
                        "key": "app-tag-name",
                        "method": "io.helidon.metrics.api.MetricsConfig.Builder#appTagName(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "defaultValue": "observe",
                        "description": "Hints for role names the user is expected to be in.\n\n @return list of hints",
                        "key": "roles",
                        "kind": "LIST",
                        "method": "io.helidon.metrics.api.MetricsConfig.Builder#roles(java.util.List<java.lang.String>)"
                    },
                    {
                        "description": "Key performance indicator metrics settings.\n\n @return key performance indicator metrics settings",
                        "key": "key-performance-indicators",
                        "method": "io.helidon.metrics.api.MetricsConfig.Builder#keyPerformanceIndicatorMetricsConfig(io.helidon.metrics.api.KeyPerformanceIndicatorMetricsConfig)",
                        "type": "io.helidon.metrics.api.KeyPerformanceIndicatorMetricsConfig"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether to allow anybody to access the endpoint.\n\n @return whether to permit access to metrics endpoint to anybody, defaults to `true`\n @see #roles()",
                        "key": "permit-all",
                        "method": "io.helidon.metrics.api.MetricsConfig.Builder#permitAll(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Settings related to scoping management.\n\n @return scoping settings",
                        "key": "scoping",
                        "method": "io.helidon.metrics.api.MetricsConfig.Builder#scoping(io.helidon.metrics.api.ScopingConfig)",
                        "type": "io.helidon.metrics.api.ScopingConfig"
                    },
                    {
                        "description": "Global tags.\n\n @return name/value pairs for global tags",
                        "key": "tags",
                        "kind": "LIST",
                        "method": "io.helidon.metrics.api.MetricsConfig.Builder#tags(java.util.List<io.helidon.metrics.api.Tag>)",
                        "type": "io.helidon.metrics.api.Tag"
                    },
                    {
                        "description": "Value for the application tag to be added to each meter ID.\n\n @return application tag value",
                        "key": "app-name",
                        "method": "io.helidon.metrics.api.MetricsConfig.Builder#appName(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether metrics functionality is enabled.\n\n @return if metrics are configured to be enabled",
                        "key": "enabled",
                        "method": "io.helidon.metrics.api.MetricsConfig.Builder#enabled(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.metrics.api.ScopeConfig",
                "type": "io.helidon.metrics.api.ScopeConfig",
                "producers": [
                    "io.helidon.metrics.api.ScopeConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.metrics.api.ScopeConfig#builder()"
                ],
                "options": [
                    {
                        "description": "Regular expression for meter names to include.\n\n @return include expression",
                        "key": "filter.include",
                        "method": "io.helidon.metrics.api.ScopeConfig.Builder#include(java.util.Optional<java.util.regex.Pattern>)",
                        "type": "java.util.regex.Pattern"
                    },
                    {
                        "description": "Name of the scope to which the configuration applies.\n\n @return scope name",
                        "key": "name",
                        "method": "io.helidon.metrics.api.ScopeConfig.Builder#name(java.lang.String)"
                    },
                    {
                        "description": "Regular expression for meter names to exclude.\n\n @return exclude expression",
                        "key": "filter.exclude",
                        "method": "io.helidon.metrics.api.ScopeConfig.Builder#exclude(java.util.Optional<java.util.regex.Pattern>)",
                        "type": "java.util.regex.Pattern"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether the scope is enabled.\n\n @return if the scope is enabled",
                        "key": "enabled",
                        "method": "io.helidon.metrics.api.ScopeConfig.Builder#enabled(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.metrics.api.ComponentMetricsSettings.Builder",
                "prefix": "metrics",
                "type": "io.helidon.metrics.api.ComponentMetricsSettings.Builder",
                "options": [
                    {
                        "description": "Sets whether metrics should be enabled for the component.",
                        "key": "enabled",
                        "method": "io.helidon.metrics.api.ComponentMetricsSettings.Builder#enabled(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.metrics.api.Tag",
                "type": "io.helidon.metrics.api.Tag",
                "options": []
            }
        ]
    }
]
[
    {
        "module": "io.helidon.metrics.api",
        "types": [
            {
                "annotatedType": "io.helidon.metrics.api.KeyPerformanceIndicatorMetricsConfig",
                "type": "io.helidon.metrics.api.KeyPerformanceIndicatorMetricsConfig",
                "producers": [
                    "io.helidon.metrics.api.KeyPerformanceIndicatorMetricsConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.metrics.api.KeyPerformanceIndicatorMetricsConfig#builder()"
                ],
                "options": [
                    {
                        "defaultValue": "PT10S",
                        "description": "Threshold in ms that characterizes whether a request is long running.\n\n @return threshold in ms indicating a long-running request",
                        "key": "long-running-requests.threshold",
                        "method": "io.helidon.metrics.api.KeyPerformanceIndicatorMetricsConfig.Builder#longRunningRequestThreshold(java.time.Duration)",
                        "type": "java.time.Duration"
                    },
                    {
                        "defaultValue": "false",
                        "description": "Whether KPI extended metrics are enabled.\n\n @return true if KPI extended metrics are enabled; false otherwise",
                        "key": "extended",
                        "method": "io.helidon.metrics.api.KeyPerformanceIndicatorMetricsConfig.Builder#extended(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.metrics.api.ScopingConfig",
                "type": "io.helidon.metrics.api.ScopingConfig",
                "producers": [
                    "io.helidon.metrics.api.ScopingConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.metrics.api.ScopingConfig#builder()"
                ],
                "options": [
                    {
                        "defaultValue": "application",
                        "description": "Default scope value to associate with meters that are registered without an explicit setting; no setting means meters\n are assigned scope {@value io.helidon.metrics.api.Meter.Scope#DEFAULT}.\n\n @return default scope value",
                        "key": "default",
                        "method": "io.helidon.metrics.api.ScopingConfig.Builder#defaultValue(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "defaultValue": "scope",
                        "description": "Tag name for storing meter scope values in the underlying implementation meter registry.\n\n @return tag name for storing scope values",
                        "key": "tag-name",
                        "method": "io.helidon.metrics.api.ScopingConfig.Builder#tagName(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "description": "Settings for individual scopes.\n\n @return scope settings",
                        "key": "scopes",
                        "kind": "MAP",
                        "method": "io.helidon.metrics.api.ScopingConfig.Builder#scopes(java.util.Map<java.lang.String, io.helidon.metrics.api.ScopeConfig>)",
                        "type": "io.helidon.metrics.api.ScopeConfig"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.metrics.api.MetricsConfig",
                "prefix": "metrics",
                "type": "io.helidon.metrics.api.MetricsConfig",
                "standalone": true,
                "producers": [
                    "io.helidon.metrics.api.MetricsConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.metrics.api.MetricsConfig#builder()"
                ],
                "options": [
                    {
                        "description": "Whether automatic REST request metrics should be measured.\n\n @return true/false",
                        "key": "rest-request-enabled",
                        "method": "io.helidon.metrics.api.MetricsConfig.Builder#restRequestEnabled(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Name for the application tag to be added to each meter ID.\n\n @return application tag name",
                        "key": "app-tag-name",
                        "method": "io.helidon.metrics.api.MetricsConfig.Builder#appTagName(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "defaultValue": "observe",
                        "description": "Hints for role names the user is expected to be in.\n\n @return list of hints",
                        "key": "roles",
                        "kind": "LIST",
                        "method": "io.helidon.metrics.api.MetricsConfig.Builder#roles(java.util.List<java.lang.String>)"
                    },
                    {
                        "description": "Key performance indicator metrics settings.\n\n @return key performance indicator metrics settings",
                        "key": "key-performance-indicators",
                        "method": "io.helidon.metrics.api.MetricsConfig.Builder#keyPerformanceIndicatorMetricsConfig(io.helidon.metrics.api.KeyPerformanceIndicatorMetricsConfig)",
                        "type": "io.helidon.metrics.api.KeyPerformanceIndicatorMetricsConfig"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether to allow anybody to access the endpoint.\n\n @return whether to permit access to metrics endpoint to anybody, defaults to `true`\n @see #roles()",
                        "key": "permit-all",
                        "method": "io.helidon.metrics.api.MetricsConfig.Builder#permitAll(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Settings related to scoping management.\n\n @return scoping settings",
                        "key": "scoping",
                        "method": "io.helidon.metrics.api.MetricsConfig.Builder#scoping(io.helidon.metrics.api.ScopingConfig)",
                        "type": "io.helidon.metrics.api.ScopingConfig"
                    },
                    {
                        "description": "Global tags.\n\n @return name/value pairs for global tags",
                        "key": "tags",
                        "kind": "LIST",
                        "method": "io.helidon.metrics.api.MetricsConfig.Builder#tags(java.util.List<io.helidon.metrics.api.Tag>)",
                        "type": "io.helidon.metrics.api.Tag"
                    },
                    {
                        "description": "Value for the application tag to be added to each meter ID.\n\n @return application tag value",
                        "key": "app-name",
                        "method": "io.helidon.metrics.api.MetricsConfig.Builder#appName(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether metrics functionality is enabled.\n\n @return if metrics are configured to be enabled",
                        "key": "enabled",
                        "method": "io.helidon.metrics.api.MetricsConfig.Builder#enabled(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.metrics.api.ScopeConfig",
                "type": "io.helidon.metrics.api.ScopeConfig",
                "producers": [
                    "io.helidon.metrics.api.ScopeConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.metrics.api.ScopeConfig#builder()"
                ],
                "options": [
                    {
                        "description": "Regular expression for meter names to include.\n\n @return include expression",
                        "key": "filter.include",
                        "method": "io.helidon.metrics.api.ScopeConfig.Builder#include(java.util.Optional<java.util.regex.Pattern>)",
                        "type": "java.util.regex.Pattern"
                    },
                    {
                        "description": "Name of the scope to which the configuration applies.\n\n @return scope name",
                        "key": "name",
                        "method": "io.helidon.metrics.api.ScopeConfig.Builder#name(java.lang.String)"
                    },
                    {
                        "description": "Regular expression for meter names to exclude.\n\n @return exclude expression",
                        "key": "filter.exclude",
                        "method": "io.helidon.metrics.api.ScopeConfig.Builder#exclude(java.util.Optional<java.util.regex.Pattern>)",
                        "type": "java.util.regex.Pattern"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether the scope is enabled.\n\n @return if the scope is enabled",
                        "key": "enabled",
                        "method": "io.helidon.metrics.api.ScopeConfig.Builder#enabled(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.metrics.api.ComponentMetricsSettings.Builder",
                "prefix": "metrics",
                "type": "io.helidon.metrics.api.ComponentMetricsSettings.Builder",
                "options": [
                    {
                        "description": "Sets whether metrics should be enabled for the component.",
                        "key": "enabled",
                        "method": "io.helidon.metrics.api.ComponentMetricsSettings.Builder#enabled(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.metrics.api.Tag",
                "type": "io.helidon.metrics.api.Tag",
                "options": []
            }
        ]
    }
]
[
    {
        "module": "io.helidon.tracing",
        "types": [
            {
                "annotatedType": "io.helidon.tracing.TracerBuilder",
                "description": "Tracer configuration.",
                "type": "io.helidon.tracing.TracerBuilder",
                "producers": [
                    "io.helidon.tracing.TracerBuilder#create(io.helidon.common.config.Config)"
                ],
                "options": []
            }
        ]
    }
]
[
    {
        "module": "io.helidon.tracing.providers.opentracing",
        "types": [
            {
                "annotatedType": "io.helidon.tracing.providers.opentracing.OpenTracingTracerBuilder",
                "description": "OpenTracing tracer configuration.",
                "type": "io.helidon.tracing.providers.opentracing.OpenTracingTracerBuilder",
                "producers": [
                    "io.helidon.tracing.providers.opentracing.OpenTracingTracerBuilder#create(io.helidon.common.config.Config)"
                ],
                "options": []
            }
        ]
    }
]
[
    {
        "module": "io.helidon.tracing",
        "types": [
            {
                "annotatedType": "io.helidon.tracing.providers.jaeger.JaegerTracerBuilder",
                "description": "Jaeger tracer configuration.",
                "prefix": "tracing",
                "type": "io.helidon.tracing.Tracer",
                "standalone": true,
                "inherits": [
                    "io.helidon.tracing.TracerBuilder"
                ],
                "producers": [
                    "io.helidon.tracing.providers.jaeger.JaegerTracerBuilder#build()"
                ],
                "options": [
                    {
                        "defaultValue": "512",
                        "description": "Maximum Export Batch Size of exporter requests.",
                        "key": "max-export-batch-size",
                        "method": "io.helidon.tracing.providers.jaeger.JaegerTracerBuilder#maxExportBatchSize(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "PT5S",
                        "description": "Schedule Delay of exporter requests.",
                        "key": "schedule-delay",
                        "method": "io.helidon.tracing.providers.jaeger.JaegerTracerBuilder#scheduleDelay(java.time.Duration)",
                        "type": "java.time.Duration"
                    },
                    {
                        "defaultValue": "JAEGER",
                        "description": "Add propagation format to use.",
                        "key": "propagation",
                        "kind": "LIST",
                        "method": "io.helidon.tracing.providers.jaeger.JaegerTracerBuilder#addPropagation(io.helidon.tracing.providers.jaeger.JaegerTracerBuilder.PropagationFormat)",
                        "type": "io.helidon.tracing.providers.jaeger.JaegerTracerBuilder.PropagationFormat",
                        "allowedValues": [
                            {
                                "description": "The Zipkin B3 trace context propagation format using multiple headers.",
                                "value": "B3"
                            },
                            {
                                "description": "B3 trace context propagation using a single header.",
                                "value": "B3_SINGLE"
                            },
                            {
                                "description": "The Jaeger trace context propagation format.",
                                "value": "JAEGER"
                            },
                            {
                                "description": "The W3C trace context propagation format.",
                                "value": "W3C"
                            }
                        ]
                    },
                    {
                        "description": "Private key in PEM format.",
                        "key": "private-key-pem",
                        "method": "io.helidon.tracing.providers.jaeger.JaegerTracerBuilder#privateKey(io.helidon.common.configurable.Resource)",
                        "type": "io.helidon.common.configurable.Resource"
                    },
                    {
                        "defaultValue": "PT10S",
                        "description": "Timeout of exporter requests.",
                        "key": "exporter-timeout",
                        "method": "io.helidon.tracing.providers.jaeger.JaegerTracerBuilder#exporterTimeout(java.time.Duration)",
                        "type": "java.time.Duration"
                    },
                    {
                        "defaultValue": "CONSTANT",
                        "description": "Sampler type.\n <p>\n See <a href=\"https://www.jaegertracing.io/docs/latest/sampling/#client-sampling-configuration\">Sampler types</a>.",
                        "key": "sampler-type",
                        "method": "io.helidon.tracing.providers.jaeger.JaegerTracerBuilder#samplerType(io.helidon.tracing.providers.jaeger.JaegerTracerBuilder.SamplerType)",
                        "type": "io.helidon.tracing.providers.jaeger.JaegerTracerBuilder.SamplerType",
                        "allowedValues": [
                            {
                                "description": "Constant sampler always makes the same decision for all traces.\n It either samples all traces `1` or none of them `0`.",
                                "value": "CONSTANT"
                            },
                            {
                                "description": "Ratio of the requests to sample, double value.",
                                "value": "RATIO"
                            }
                        ]
                    },
                    {
                        "description": "Trusted certificates in PEM format.",
                        "key": "trusted-cert-pem",
                        "method": "io.helidon.tracing.providers.jaeger.JaegerTracerBuilder#trustedCertificates(io.helidon.common.configurable.Resource)",
                        "type": "io.helidon.common.configurable.Resource"
                    },
                    {
                        "defaultValue": "batch",
                        "description": "Span Processor type used.",
                        "key": "span-processor-type",
                        "method": "io.helidon.tracing.providers.jaeger.JaegerTracerBuilder#spanProcessorType(io.helidon.tracing.providers.jaeger.JaegerTracerBuilder.SpanProcessorType)",
                        "type": "io.helidon.tracing.providers.jaeger.JaegerTracerBuilder.SpanProcessorType",
                        "allowedValues": [
                            {
                                "description": "Simple Span Processor.",
                                "value": "SIMPLE"
                            },
                            {
                                "description": "Batch Span Processor.",
                                "value": "BATCH"
                            }
                        ]
                    },
                    {
                        "defaultValue": "1",
                        "description": "The sampler parameter (number).",
                        "key": "sampler-param",
                        "method": "io.helidon.tracing.providers.jaeger.JaegerTracerBuilder#samplerParam(java.lang.Number)",
                        "type": "java.lang.Number"
                    },
                    {
                        "description": "Certificate of client in PEM format.",
                        "key": "client-cert-pem",
                        "method": "io.helidon.tracing.providers.jaeger.JaegerTracerBuilder#clientCertificate(io.helidon.common.configurable.Resource)",
                        "type": "io.helidon.common.configurable.Resource"
                    },
                    {
                        "defaultValue": "2048",
                        "description": "Maximum Queue Size of exporter requests.",
                        "key": "max-queue-size",
                        "method": "io.helidon.tracing.providers.jaeger.JaegerTracerBuilder#maxQueueSize(int)",
                        "type": "java.lang.Integer"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.opentracing.api",
        "types": [
            {
                "annotatedType": "io.helidon.tracing.providers.zipkin.ZipkinTracerBuilder",
                "description": "Zipkin tracer configuration",
                "prefix": "tracing",
                "type": "io.opentracing.Tracer",
                "standalone": true,
                "inherits": [
                    "io.helidon.tracing.providers.opentracing.OpenTracingTracerBuilder"
                ],
                "producers": [
                    "io.helidon.tracing.providers.zipkin.ZipkinTracerBuilder#build()"
                ],
                "options": [
                    {
                        "defaultValue": "V2",
                        "description": "Version of Zipkin API to use.\n Defaults to Version#V2.",
                        "key": "api-version",
                        "method": "io.helidon.tracing.providers.zipkin.ZipkinTracerBuilder#version(io.helidon.tracing.providers.zipkin.ZipkinTracerBuilder.Version)",
                        "type": "io.helidon.tracing.providers.zipkin.ZipkinTracerBuilder.Version",
                        "allowedValues": [
                            {
                                "description": "Version 1.",
                                "value": "V1"
                            },
                            {
                                "description": "Version 2.",
                                "value": "V2"
                            }
                        ]
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.dbclient.jdbc",
        "types": [
            {
                "annotatedType": "io.helidon.dbclient.jdbc.JdbcParametersConfig",
                "prefix": "parameters",
                "type": "io.helidon.dbclient.jdbc.JdbcParametersConfig",
                "producers": [
                    "io.helidon.dbclient.jdbc.JdbcParametersConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.dbclient.jdbc.JdbcParametersConfig#builder()"
                ],
                "options": [
                    {
                        "defaultValue": "true",
                        "description": "Use java.sql.PreparedStatement#setBinaryStream(int, java.io.InputStream, int) binding\n for `byte[]` values.\n Default value is `true`.\n\n @return whether to use java.io.ByteArrayInputStream binding",
                        "key": "use-byte-array-binding",
                        "method": "io.helidon.dbclient.jdbc.JdbcParametersConfig.Builder#useByteArrayBinding(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Use java.sql.PreparedStatement#setCharacterStream(int, java.io.Reader, int) binding\n for String values with length above #stringBindingSize() limit.\n Default value is `true`.\n\n @return whether to use java.io.CharArrayReader binding",
                        "key": "use-string-binding",
                        "method": "io.helidon.dbclient.jdbc.JdbcParametersConfig.Builder#useStringBinding(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Use java.sql.PreparedStatement#setTimestamp(int, java.sql.Timestamp)\n to set java.time.LocalTime values when `true`\n or use java.sql.PreparedStatement#setTime(int, java.sql.Time) when `false`.\n Default value is `true`.\n <p>This option is vendor specific. Most of the databases are fine with java.sql.Timestamp,\n but for example SQL Server requires java.sql.Time.\n This option does not apply when #setObjectForJavaTime() is set to `true`.\n\n @return whether to use java.sql.Timestamp instead of java.sql.Time\n         for java.time.LocalTime values",
                        "key": "timestamp-for-local-time",
                        "method": "io.helidon.dbclient.jdbc.JdbcParametersConfig.Builder#timestampForLocalTime(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "false",
                        "description": "Use SQL `NCHAR`, `NVARCHAR` or `LONGNVARCHAR` value conversion\n for String values.\n Default value is `false`.\n\n @return whether NString conversion is used",
                        "key": "use-n-string",
                        "method": "io.helidon.dbclient.jdbc.JdbcParametersConfig.Builder#useNString(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "1024",
                        "description": "String values with length above this limit will be bound\n using java.sql.PreparedStatement#setCharacterStream(int, java.io.Reader, int)\n if #useStringBinding() is set to `true`.\n Default value is `1024`.\n\n @return String values length limit for java.io.CharArrayReader binding",
                        "key": "string-binding-size",
                        "method": "io.helidon.dbclient.jdbc.JdbcParametersConfig.Builder#stringBindingSize(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Set all `java.time` Date/Time values directly using java.sql.PreparedStatement#setObject(int, Object).\n This option shall work fine for recent JDBC drivers.\n Default value is `true`.\n\n @return whether to use java.sql.PreparedStatement#setObject(int, Object) for `java.time` Date/Time values",
                        "key": "set-object-for-java-time",
                        "method": "io.helidon.dbclient.jdbc.JdbcParametersConfig.Builder#setObjectForJavaTime(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.scheduling",
        "types": [
            {
                "annotatedType": "io.helidon.scheduling.TaskConfig",
                "type": "io.helidon.scheduling.TaskConfig",
                "producers": [
                    "io.helidon.scheduling.TaskConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.scheduling.TaskConfig#builder()"
                ],
                "options": []
            },
            {
                "annotatedType": "io.helidon.scheduling.FixedRateConfig",
                "type": "io.helidon.scheduling.FixedRate",
                "inherits": [
                    "io.helidon.scheduling.TaskConfig"
                ],
                "producers": [
                    "io.helidon.scheduling.FixedRateConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.scheduling.FixedRateConfig#builder()",
                    "io.helidon.scheduling.FixedRate#create(io.helidon.scheduling.FixedRateConfig)"
                ],
                "options": [
                    {
                        "description": "Fixed rate delay between each invocation. Time unit is by default java.util.concurrent.TimeUnit#SECONDS,\n can be specified with io.helidon.scheduling.FixedRateConfig.Builder#timeUnit(java.util.concurrent.TimeUnit).\n\n @return delay between each invocation",
                        "key": "delay",
                        "method": "io.helidon.scheduling.FixedRateConfig.Builder#delay(long)",
                        "type": "java.lang.Long",
                        "required": true
                    },
                    {
                        "defaultValue": "SINCE_PREVIOUS_START",
                        "description": "Configure whether the delay between the invocations should be calculated from the time when previous task started or ended.\n Delay type is by default FixedRate.DelayType#SINCE_PREVIOUS_START.\n\n @return delay type",
                        "key": "delay-type",
                        "method": "io.helidon.scheduling.FixedRateConfig.Builder#delayType(io.helidon.scheduling.FixedRate.DelayType)",
                        "type": "io.helidon.scheduling.FixedRate.DelayType",
                        "allowedValues": [
                            {
                                "description": "Next invocation delay is measured from the previous invocation task start.",
                                "value": "SINCE_PREVIOUS_START"
                            },
                            {
                                "description": "Next invocation delay is measured from the previous invocation task end.",
                                "value": "SINCE_PREVIOUS_END"
                            }
                        ]
                    },
                    {
                        "defaultValue": "TimeUnit.SECONDS",
                        "description": "java.util.concurrent.TimeUnit TimeUnit used for interpretation of values provided with\n io.helidon.scheduling.FixedRateConfig.Builder#delay(long)\n and io.helidon.scheduling.FixedRateConfig.Builder#initialDelay(long).\n\n @return time unit for interpreting values\n         in io.helidon.scheduling.FixedRateConfig.Builder#delay(long)\n         and io.helidon.scheduling.FixedRateConfig.Builder#initialDelay(long)",
                        "key": "time-unit",
                        "method": "io.helidon.scheduling.FixedRateConfig.Builder#timeUnit(java.util.concurrent.TimeUnit)",
                        "type": "java.util.concurrent.TimeUnit",
                        "allowedValues": [
                            {
                                "description": "",
                                "value": "NANOSECONDS"
                            },
                            {
                                "description": "",
                                "value": "MICROSECONDS"
                            },
                            {
                                "description": "",
                                "value": "MILLISECONDS"
                            },
                            {
                                "description": "",
                                "value": "SECONDS"
                            },
                            {
                                "description": "",
                                "value": "MINUTES"
                            },
                            {
                                "description": "",
                                "value": "HOURS"
                            },
                            {
                                "description": "",
                                "value": "DAYS"
                            }
                        ]
                    },
                    {
                        "defaultValue": "0",
                        "description": "Initial delay of the first invocation. Time unit is by default java.util.concurrent.TimeUnit#SECONDS,\n can be specified with\n io.helidon.scheduling.FixedRateConfig.Builder#timeUnit(java.util.concurrent.TimeUnit) timeUnit().\n\n @return initial delay value",
                        "key": "initial-delay",
                        "method": "io.helidon.scheduling.FixedRateConfig.Builder#initialDelay(long)",
                        "type": "java.lang.Long"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.scheduling.CronConfig",
                "type": "io.helidon.scheduling.Cron",
                "inherits": [
                    "io.helidon.scheduling.TaskConfig"
                ],
                "producers": [
                    "io.helidon.scheduling.CronConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.scheduling.CronConfig#builder()",
                    "io.helidon.scheduling.Cron#create(io.helidon.scheduling.CronConfig)"
                ],
                "options": [
                    {
                        "defaultValue": "true",
                        "description": "Allow concurrent execution if previous task didn't finish before next execution.\n Default value is `true`.\n\n @return true for allow concurrent execution.",
                        "key": "concurrent",
                        "method": "io.helidon.scheduling.CronConfig.Builder#concurrentExecution(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Cron expression for specifying period of execution.\n <p>\n <b>Examples:</b>\n <ul>\n <li>`0/2 * * * * ? *` - Every 2 seconds</li>\n <li>`0 45 9 ? * *` - Every day at 9:45</li>\n <li>`0 15 8 ? * MON-FRI` - Every workday at 8:15</li>\n </ul>\n\n @return cron expression",
                        "key": "expression",
                        "method": "io.helidon.scheduling.CronConfig.Builder#expression(java.lang.String)",
                        "required": true
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.config.tests.config.metadata.meta.api",
        "types": [
            {
                "annotatedType": "io.helidon.config.tests.config.metadata.meta.api.MyBuilder",
                "description": "builder",
                "type": "io.helidon.config.tests.config.metadata.meta.api.MyTarget",
                "inherits": [
                    "io.helidon.config.tests.config.metadata.meta.api.AbstractBuilder"
                ],
                "producers": [
                    "io.helidon.config.tests.config.metadata.meta.api.MyBuilder#build()"
                ],
                "options": [
                    {
                        "defaultValue": "message",
                        "description": "message description",
                        "key": "message",
                        "method": "io.helidon.config.tests.config.metadata.meta.api.MyBuilder#message(java.lang.String)"
                    },
                    {
                        "defaultValue": "42",
                        "description": "type description",
                        "key": "type",
                        "method": "io.helidon.config.tests.config.metadata.meta.api.MyBuilder#type(int)",
                        "type": "java.lang.Integer",
                        "allowedValues": [
                            {
                                "description": "answer",
                                "value": "42"
                            },
                            {
                                "description": "no answer",
                                "value": "0"
                            }
                        ]
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.config.tests.config.metadata.meta.api.AbstractBuilder",
                "description": "abstract builder",
                "type": "io.helidon.config.tests.config.metadata.meta.api.AbstractBuilder",
                "options": [
                    {
                        "description": "abstract description",
                        "key": "abstract-message",
                        "method": "io.helidon.config.tests.config.metadata.meta.api.AbstractBuilder#abstractMessage(java.lang.String)"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.config.tests.config.metadata.builder.api",
        "types": [
            {
                "annotatedType": "io.helidon.config.tests.config.metadata.builder.api.MyAbstract",
                "description": "abstract builder",
                "type": "io.helidon.config.tests.config.metadata.builder.api.MyAbstract",
                "producers": [
                    "io.helidon.config.tests.config.metadata.builder.api.MyAbstract#create(io.helidon.common.config.Config)",
                    "io.helidon.config.tests.config.metadata.builder.api.MyAbstract#builder()"
                ],
                "options": [
                    {
                        "description": "abstract description",
                        "key": "abstract-message",
                        "method": "io.helidon.config.tests.config.metadata.builder.api.MyAbstract.Builder#abstractMessage(java.lang.String)"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.config.tests.config.metadata.builder.api.MyTarget",
                "description": "builder",
                "type": "io.helidon.config.tests.config.metadata.builder.api.MyTarget",
                "inherits": [
                    "io.helidon.config.tests.config.metadata.builder.api.MyAbstract"
                ],
                "producers": [
                    "io.helidon.config.tests.config.metadata.builder.api.MyTarget#create(io.helidon.common.config.Config)",
                    "io.helidon.config.tests.config.metadata.builder.api.MyTarget#builder()"
                ],
                "options": [
                    {
                        "defaultValue": "message",
                        "description": "message description",
                        "key": "message",
                        "method": "io.helidon.config.tests.config.metadata.builder.api.MyTarget.Builder#message(java.lang.String)"
                    },
                    {
                        "defaultValue": "42",
                        "description": "type description",
                        "key": "type",
                        "method": "io.helidon.config.tests.config.metadata.builder.api.MyTarget.Builder#type(int)",
                        "type": "java.lang.Integer",
                        "allowedValues": [
                            {
                                "description": "answer",
                                "value": "42"
                            },
                            {
                                "description": "no answer",
                                "value": "0"
                            }
                        ]
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "microprofile.config.api",
        "types": [
            {
                "annotatedType": "io.helidon.config.mp.MpConfigBuilder",
                "prefix": "mp.config",
                "type": "org.eclipse.microprofile.config.Config",
                "standalone": true,
                "producers": [
                    "io.helidon.config.mp.MpConfigBuilder#build()"
                ],
                "options": [
                    {
                        "description": "Configure an explicit profile name.",
                        "key": "profile",
                        "method": "io.helidon.config.mp.MpConfigBuilder#profile(java.lang.String)"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.security.util",
        "types": [
            {
                "annotatedType": "io.helidon.security.util.TokenHandler.Builder",
                "type": "io.helidon.security.util.TokenHandler",
                "producers": [
                    "io.helidon.security.util.TokenHandler.Builder#build()",
                    "io.helidon.security.util.TokenHandler#create(io.helidon.common.config.Config)"
                ],
                "options": [
                    {
                        "description": "Set the token pattern (Regular expression) to extract the token.",
                        "key": "regexp",
                        "method": "io.helidon.security.util.TokenHandler.Builder#tokenPattern(java.util.regex.Pattern)"
                    },
                    {
                        "description": "Set the prefix of header value to extract the token.",
                        "key": "prefix",
                        "method": "io.helidon.security.util.TokenHandler.Builder#tokenPrefix(java.lang.String)"
                    },
                    {
                        "description": "Set the name of header to look into to extract the token.",
                        "key": "header",
                        "method": "io.helidon.security.util.TokenHandler.Builder#tokenHeader(java.lang.String)"
                    },
                    {
                        "description": "Token format for creating outbound tokens.",
                        "key": "format",
                        "method": "io.helidon.security.util.TokenHandler.Builder#tokenFormat(java.lang.String)"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.security",
        "types": [
            {
                "annotatedType": "io.helidon.security.Security.Builder",
                "description": "Configuration of security providers, integration and other security options",
                "prefix": "security",
                "type": "io.helidon.security.Security",
                "standalone": true,
                "producers": [
                    "io.helidon.security.Security.Builder#build()",
                    "io.helidon.security.Security#create(io.helidon.common.config.Config)"
                ],
                "options": [
                    {
                        "defaultValue": "FIRST",
                        "description": "Type of the policy.",
                        "key": "provider-policy.type",
                        "method": "io.helidon.security.Security.Builder#providerSelectionPolicy(java.util.function.Function<io.helidon.security.spi.ProviderSelectionPolicy.Providers, io.helidon.security.spi.ProviderSelectionPolicy>)",
                        "type": "io.helidon.security.ProviderSelectionPolicyType",
                        "allowedValues": [
                            {
                                "description": "Choose first provider from the list by default.\n Choose provider with the name defined when explicit provider requested.",
                                "value": "FIRST"
                            },
                            {
                                "description": "Can compose multiple providers together to form a single\n logical provider.",
                                "value": "COMPOSITE"
                            },
                            {
                                "description": "Explicit class for a custom ProviderSelectionPolicyType.",
                                "value": "CLASS"
                            }
                        ]
                    },
                    {
                        "description": "ID of the default authentication provider",
                        "key": "default-authentication-provider",
                        "method": "io.helidon.security.Security.Builder#authenticationProvider(io.helidon.security.spi.AuthenticationProvider)",
                        "providerType": "java.lang.String",
                        "provider": true
                    },
                    {
                        "description": "Name of the secret provider",
                        "key": "secrets.*.provider",
                        "method": "io.helidon.security.Security.Builder#addSecret(java.lang.String, io.helidon.security.spi.SecretsProvider<T>, T)"
                    },
                    {
                        "description": "Provider selection policy class name, only used when type is set to CLASS",
                        "key": "provider-policy.class-name",
                        "method": "io.helidon.security.Security.Builder#providerSelectionPolicy(java.util.function.Function<io.helidon.security.spi.ProviderSelectionPolicy.Providers, io.helidon.security.spi.ProviderSelectionPolicy>)",
                        "type": "java.lang.Class"
                    },
                    {
                        "description": "Configuration specific to the secret provider",
                        "key": "secrets.*.config",
                        "method": "io.helidon.security.Security.Builder#addSecret(java.lang.String, io.helidon.security.spi.SecretsProvider<T>, T)",
                        "providerType": "io.helidon.security.SecretsProviderConfig",
                        "type": "io.helidon.security.SecretsProviderConfig",
                        "provider": true
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether or not tracing should be enabled. If set to false, security tracer will be a no-op tracer.",
                        "key": "tracing.enabled",
                        "method": "io.helidon.security.Security.Builder#tracingEnabled(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Server time to use when evaluating security policies that depend on time.",
                        "key": "environment.server-time",
                        "method": "io.helidon.security.Security.Builder#serverTime(io.helidon.security.SecurityTime)",
                        "type": "io.helidon.security.SecurityTime"
                    },
                    {
                        "description": "ID of the default authorization provider",
                        "key": "default-authorization-provider",
                        "method": "io.helidon.security.Security.Builder#authorizationProvider(io.helidon.security.spi.AuthorizationProvider)"
                    },
                    {
                        "description": "Configured secrets",
                        "key": "secrets",
                        "kind": "LIST",
                        "method": "io.helidon.security.Security.Builder#addSecret(java.lang.String, io.helidon.security.spi.SecretsProvider<T>, T)",
                        "type": "io.helidon.common.config.Config"
                    },
                    {
                        "description": "Add a provider, works as #addProvider(io.helidon.security.spi.SecurityProvider, String), where the name is set\n to {@link\n Class#getSimpleName()}.",
                        "key": "providers",
                        "kind": "LIST",
                        "method": "io.helidon.security.Security.Builder#addProvider(io.helidon.security.spi.SecurityProvider)",
                        "providerType": "io.helidon.security.spi.SecurityProvider",
                        "type": "io.helidon.security.spi.SecurityProvider",
                        "provider": true,
                        "required": true
                    },
                    {
                        "defaultValue": "true",
                        "description": "Security can be disabled using configuration, or explicitly.\n By default, security instance is enabled.\n Disabled security instance will not perform any checks and allow\n all requests.",
                        "key": "enabled",
                        "method": "io.helidon.security.Security.Builder#enabled(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Name of the secret, used for lookup",
                        "key": "secrets.*.name",
                        "method": "io.helidon.security.Security.Builder#addSecret(java.lang.String, io.helidon.security.spi.SecretsProvider<T>, T)"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.security.SecurityTime.Builder",
                "type": "io.helidon.security.SecurityTime",
                "producers": [
                    "io.helidon.security.SecurityTime.Builder#build()",
                    "io.helidon.security.SecurityTime#create(io.helidon.common.config.Config)"
                ],
                "options": [
                    {
                        "defaultValue": "0",
                        "description": "Configure a time-shift in seconds, to move the current time to past or future.",
                        "key": "shift-by-seconds",
                        "method": "io.helidon.security.SecurityTime.Builder#shiftBySeconds(long)",
                        "type": "java.lang.Long"
                    },
                    {
                        "description": "Set an explicit value for one of the time fields (such as ChronoField#YEAR).",
                        "key": "year",
                        "method": "io.helidon.security.SecurityTime.Builder#value(java.time.temporal.ChronoField, long)",
                        "type": "java.lang.Long"
                    },
                    {
                        "description": "Set an explicit value for one of the time fields (such as ChronoField#YEAR).",
                        "key": "millisecond",
                        "method": "io.helidon.security.SecurityTime.Builder#value(java.time.temporal.ChronoField, long)",
                        "type": "java.lang.Long"
                    },
                    {
                        "description": "Set an explicit value for one of the time fields (such as ChronoField#YEAR).",
                        "key": "minute",
                        "method": "io.helidon.security.SecurityTime.Builder#value(java.time.temporal.ChronoField, long)",
                        "type": "java.lang.Long"
                    },
                    {
                        "description": "Set an explicit value for one of the time fields (such as ChronoField#YEAR).",
                        "key": "second",
                        "method": "io.helidon.security.SecurityTime.Builder#value(java.time.temporal.ChronoField, long)",
                        "type": "java.lang.Long"
                    },
                    {
                        "description": "Override current time zone. The time will represent the SAME instant, in an explicit timezone.\n <p>\n If we are in a UTC time zone and you set the timezone to \"Europe/Prague\", the time will be shifted by the offset\n of Prague (e.g. if it is noon right now in UTC, you would get 14:00).",
                        "key": "time-zone",
                        "method": "io.helidon.security.SecurityTime.Builder#timeZone(java.time.ZoneId)",
                        "type": "java.time.ZoneId"
                    },
                    {
                        "description": "Set an explicit value for one of the time fields (such as ChronoField#YEAR).",
                        "key": "month",
                        "method": "io.helidon.security.SecurityTime.Builder#value(java.time.temporal.ChronoField, long)",
                        "type": "java.lang.Long"
                    },
                    {
                        "description": "Set an explicit value for one of the time fields (such as ChronoField#YEAR).",
                        "key": "day-of-month",
                        "method": "io.helidon.security.SecurityTime.Builder#value(java.time.temporal.ChronoField, long)",
                        "type": "java.lang.Long"
                    },
                    {
                        "description": "Set an explicit value for one of the time fields (such as ChronoField#YEAR).",
                        "key": "hour-of-day",
                        "method": "io.helidon.security.SecurityTime.Builder#value(java.time.temporal.ChronoField, long)",
                        "type": "java.lang.Long"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.security.providers.jwt",
        "types": [
            {
                "annotatedType": "io.helidon.security.providers.jwt.JwtProvider.Builder",
                "description": "JWT authentication provider",
                "prefix": "jwt",
                "type": "io.helidon.security.providers.jwt.JwtProvider",
                "producers": [
                    "io.helidon.security.providers.jwt.JwtProvider.Builder#build()",
                    "io.helidon.security.providers.jwt.JwtProvider#create(io.helidon.common.config.Config)"
                ],
                "provides": [
                    "io.helidon.security.spi.SecurityProvider",
                    "io.helidon.security.spi.AuthenticationProvider"
                ],
                "options": [
                    {
                        "defaultValue": "true",
                        "description": "Whether to authenticate requests.",
                        "key": "authenticate",
                        "method": "io.helidon.security.providers.jwt.JwtProvider.Builder#authenticate(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "JWK resource used to verify JWTs created by other parties.",
                        "key": "atn-token.jwk.resource",
                        "method": "io.helidon.security.providers.jwt.JwtProvider.Builder#verifyJwk(io.helidon.common.configurable.Resource)",
                        "type": "io.helidon.common.configurable.Resource"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Claim `groups` from JWT will be used to automatically add\n  groups to current subject (may be used with jakarta.annotation.security.RolesAllowed annotation).",
                        "key": "use-jwt-groups",
                        "method": "io.helidon.security.providers.jwt.JwtProvider.Builder#useJwtGroups(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "false",
                        "description": "Whether to allow impersonation by explicitly overriding\n username from outbound requests using io.helidon.security.EndpointConfig#PROPERTY_OUTBOUND_ID\n property.\n By default this is not allowed and identity can only be propagated.",
                        "key": "allow-impersonation",
                        "method": "io.helidon.security.providers.jwt.JwtProvider.Builder#allowImpersonation(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Issuer used to create new JWTs.",
                        "key": "sign-token.jwt-issuer",
                        "method": "io.helidon.security.providers.jwt.JwtProvider.Builder#issuer(java.lang.String)"
                    },
                    {
                        "defaultValue": "USER",
                        "description": "Principal type this provider extracts (and also propagates).",
                        "key": "principal-type",
                        "method": "io.helidon.security.providers.jwt.JwtProvider.Builder#subjectType(io.helidon.security.SubjectType)",
                        "type": "io.helidon.security.SubjectType",
                        "allowedValues": [
                            {
                                "description": "",
                                "value": "USER"
                            },
                            {
                                "description": "",
                                "value": "SERVICE"
                            }
                        ]
                    },
                    {
                        "description": "JWK resource used to sign JWTs created by us.",
                        "key": "sign-token.jwk.resource",
                        "method": "io.helidon.security.providers.jwt.JwtProvider.Builder#signJwk(io.helidon.common.configurable.Resource)",
                        "type": "io.helidon.common.configurable.Resource"
                    },
                    {
                        "defaultValue": "false",
                        "description": "Whether authentication is required.\n By default, request will fail if the username cannot be extracted.\n If set to false, request will process and this provider will abstain.",
                        "key": "optional",
                        "method": "io.helidon.security.providers.jwt.JwtProvider.Builder#optional(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether to propagate identity.",
                        "key": "propagate",
                        "method": "io.helidon.security.providers.jwt.JwtProvider.Builder#propagate(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "false",
                        "description": "Configure support for unsigned JWT.\n If this is set to `true` any JWT that has algorithm\n set to `none` and no `kid` defined will be accepted.\n Note that this has serious security impact - if JWT can be sent\n  from a third party, this allows the third party to send ANY JWT\n  and it would be accpted as valid.",
                        "key": "allow-unsigned",
                        "method": "io.helidon.security.providers.jwt.JwtProvider.Builder#allowUnsigned(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Token handler to extract username from request.",
                        "key": "atn-token.handler",
                        "method": "io.helidon.security.providers.jwt.JwtProvider.Builder#atnTokenHandler(io.helidon.security.util.TokenHandler)",
                        "type": "io.helidon.security.util.TokenHandler"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Configure whether to verify signatures.\n Signatures verification is enabled by default. You can configure the provider\n not to verify signatures.\n <p>\n <b>Make sure your service is properly secured on network level and only\n accessible from a secure endpoint that provides the JWTs when signature verification\n is disabled. If signature verification is disabled, this service will accept <i>ANY</i> JWT</b>",
                        "key": "atn-token.verify-signature",
                        "method": "io.helidon.security.providers.jwt.JwtProvider.Builder#verifySignature(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Audience expected in inbound JWTs.",
                        "key": "atn-token.jwt-audience",
                        "method": "io.helidon.security.providers.jwt.JwtProvider.Builder#expectedAudience(java.lang.String)"
                    },
                    {
                        "description": "Configuration of outbound rules.",
                        "key": "sign-token",
                        "method": "io.helidon.security.providers.jwt.JwtProvider.Builder#outboundConfig(io.helidon.security.providers.common.OutboundConfig)",
                        "type": "io.helidon.security.providers.common.OutboundConfig"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.security.providers.httpsign",
        "types": [
            {
                "annotatedType": "io.helidon.security.providers.httpsign.HttpSignProvider.Builder",
                "description": "HTTP header signature provider.",
                "prefix": "http-signatures",
                "type": "io.helidon.security.providers.httpsign.HttpSignProvider",
                "producers": [
                    "io.helidon.security.providers.httpsign.HttpSignProvider.Builder#build()",
                    "io.helidon.security.providers.httpsign.HttpSignProvider#create(io.helidon.common.config.Config)"
                ],
                "provides": [
                    "io.helidon.security.spi.AuthenticationProvider"
                ],
                "options": [
                    {
                        "description": "Add a header that is validated on inbound requests. Provider may support more than\n one header to validate.",
                        "key": "headers",
                        "kind": "LIST",
                        "method": "io.helidon.security.providers.httpsign.HttpSignProvider.Builder#addAcceptHeader(io.helidon.security.providers.httpsign.HttpSignHeader)",
                        "type": "io.helidon.security.providers.httpsign.HttpSignHeader",
                        "allowedValues": [
                            {
                                "description": "Creates (or validates) a \"Signature\" header.",
                                "value": "SIGNATURE"
                            },
                            {
                                "description": "Creates (or validates) an \"Authorization\" header, that contains \"Signature\" as the\n beginning of its content (the rest of the header is the same as for #SIGNATURE.",
                                "value": "AUTHORIZATION"
                            },
                            {
                                "description": "Custom provided using a io.helidon.security.util.TokenHandler.",
                                "value": "CUSTOM"
                            }
                        ]
                    },
                    {
                        "defaultValue": "true",
                        "description": "Set whether the signature is optional. If set to true (default), this provider will\n SecurityResponse.SecurityStatus#ABSTAIN from this request if signature is not\n present. If set to false, this provider will SecurityResponse.SecurityStatus#FAILURE fail\n if signature is not present.",
                        "key": "optional",
                        "method": "io.helidon.security.providers.httpsign.HttpSignProvider.Builder#optional(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "false",
                        "description": "Enable support for Helidon versions before 3.0.0 (exclusive).\n <p>\n Until version 3.0.0 (exclusive) there was a trailing end of line added to the signed\n data.\n To be able to communicate cross versions, we must configure this when talking to older versions of Helidon.\n Default value is `false`. In Helidon 2.x, this switch exists as well and the default is `true`, to\n allow communication between versions as needed.",
                        "key": "backward-compatible-eol",
                        "method": "io.helidon.security.providers.httpsign.HttpSignProvider.Builder#backwardCompatibleEol(java.lang.Boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Add outbound targets to this builder.\n The targets are used to chose what to do for outbound communication.\n The targets should have OutboundTargetDefinition attached through\n OutboundTarget.Builder#customObject(Class, Object) to tell us how to sign\n the request.\n <p>\n The same can be done through configuration:\n <pre>\n {\n  name = \"http-signatures\"\n  class = \"HttpSignProvider\"\n  http-signatures {\n      targets: [\n      {\n          name = \"service2\"\n          hosts = [\"localhost\"]\n          paths = [\"/service2/.*\"]\n\n          # This configures the OutboundTargetDefinition\n          signature {\n              key-id = \"service1\"\n              hmac.secret = \"${CLEAR=password}\"\n          }\n      }]\n  }\n }\n </pre>",
                        "key": "outbound",
                        "method": "io.helidon.security.providers.httpsign.HttpSignProvider.Builder#outbound(io.helidon.security.providers.common.OutboundConfig)",
                        "type": "io.helidon.security.providers.common.OutboundConfig"
                    },
                    {
                        "description": "Add inbound configuration. This is used to validate signature and authenticate the\n party.\n <p>\n The same can be done through configuration:\n <pre>\n {\n  name = \"http-signatures\"\n  class = \"HttpSignProvider\"\n  http-signatures {\n      inbound {\n          # This configures the InboundClientDefinition\n          keys: [\n          {\n              key-id = \"service1\"\n              hmac.secret = \"${CLEAR=password}\"\n          }]\n      }\n  }\n }\n </pre>",
                        "key": "inbound.keys",
                        "kind": "LIST",
                        "method": "io.helidon.security.providers.httpsign.HttpSignProvider.Builder#addInbound(io.helidon.security.providers.httpsign.InboundClientDefinition)",
                        "type": "io.helidon.security.providers.httpsign.InboundClientDefinition"
                    },
                    {
                        "defaultValue": "helidon",
                        "description": "Realm to use for challenging inbound requests that do not have \"Authorization\" header\n in case header is HttpSignHeader#AUTHORIZATION and singatures are not optional.",
                        "key": "realm",
                        "method": "io.helidon.security.providers.httpsign.HttpSignProvider.Builder#realm(java.lang.String)"
                    },
                    {
                        "description": "Override the default inbound required headers (e.g. headers that MUST be signed and\n headers that MUST be signed IF present).\n <p>\n Defaults:\n <ul>\n <li>get, head, delete methods: date, (request-target), host are mandatory; authorization if present (unless we are\n creating/validating the HttpSignHeader#AUTHORIZATION ourselves</li>\n <li>put, post: same as above, with addition of: content-length, content-type and digest if present\n <li>for other methods: date, (request-target)</li>\n </ul>\n Note that this provider DOES NOT validate the \"Digest\" HTTP header, only the signature.",
                        "key": "sign-headers",
                        "kind": "LIST",
                        "method": "io.helidon.security.providers.httpsign.HttpSignProvider.Builder#inboundRequiredHeaders(io.helidon.security.providers.httpsign.SignedHeadersConfig)",
                        "type": "io.helidon.security.providers.httpsign.SignedHeadersConfig.HeadersConfig"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.security.providers.httpsign.InboundClientDefinition.Builder",
                "type": "io.helidon.security.providers.httpsign.InboundClientDefinition",
                "producers": [
                    "io.helidon.security.providers.httpsign.InboundClientDefinition.Builder#build()",
                    "io.helidon.security.providers.httpsign.InboundClientDefinition#create(io.helidon.common.config.Config)"
                ],
                "options": [
                    {
                        "description": "The key id of this client to map to this signature validation configuration.",
                        "key": "key-id",
                        "method": "io.helidon.security.providers.httpsign.InboundClientDefinition.Builder#keyId(java.lang.String)"
                    },
                    {
                        "description": "For algorithms based on public/private key (such as rsa-sha256), this provides access to the public key of the client.",
                        "key": "public-key",
                        "method": "io.helidon.security.providers.httpsign.InboundClientDefinition.Builder#publicKeyConfig(io.helidon.common.pki.Keys)",
                        "type": "io.helidon.common.pki.Keys"
                    },
                    {
                        "description": "Helper method to configure a password-like secret (instead of byte based #hmacSecret(byte[]).\n The password is transformed to bytes with StandardCharsets#UTF_8 charset.",
                        "key": "hmac.secret",
                        "method": "io.helidon.security.providers.httpsign.InboundClientDefinition.Builder#hmacSecret(java.lang.String)"
                    },
                    {
                        "description": "The principal name of the client, defaults to keyId if not configured.",
                        "key": "principal-name",
                        "method": "io.helidon.security.providers.httpsign.InboundClientDefinition.Builder#principalName(java.lang.String)"
                    },
                    {
                        "description": "Algorithm of signature used by this client.\n Currently supported:\n <ul>\n <li>rsa-sha256 - asymmetric based on public/private keys</li>\n <li>hmac-sha256 - symmetric based on a shared secret</li>\n </ul>",
                        "key": "algorithm",
                        "method": "io.helidon.security.providers.httpsign.InboundClientDefinition.Builder#algorithm(java.lang.String)"
                    },
                    {
                        "defaultValue": "SERVICE",
                        "description": "The type of principal we have authenticated (either user or service, defaults to service).",
                        "key": "principal-type",
                        "method": "io.helidon.security.providers.httpsign.InboundClientDefinition.Builder#subjectType(io.helidon.security.SubjectType)",
                        "type": "io.helidon.security.SubjectType",
                        "allowedValues": [
                            {
                                "description": "",
                                "value": "USER"
                            },
                            {
                                "description": "",
                                "value": "SERVICE"
                            }
                        ]
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.security.providers.httpsign.SignedHeadersConfig.HeadersConfig",
                "type": "io.helidon.security.providers.httpsign.SignedHeadersConfig.HeadersConfig",
                "producers": [
                    "io.helidon.security.providers.httpsign.SignedHeadersConfig.HeadersConfig#create(io.helidon.common.config.Config)"
                ],
                "options": [
                    {
                        "description": "Headers that must be signed (and signature validation or creation should fail if not signed or present)",
                        "key": "always",
                        "kind": "LIST"
                    },
                    {
                        "description": "Headers that must be signed if present in request.",
                        "key": "if-present",
                        "kind": "LIST"
                    },
                    {
                        "description": "HTTP method this header configuration is bound to. If not present, it is considered default header configuration.",
                        "key": "method"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.security.providers.oidc.common",
        "types": [
            {
                "annotatedType": "io.helidon.security.providers.oidc.common.OidcConfig.Builder",
                "description": "Open ID Connect configuration",
                "type": "io.helidon.security.providers.oidc.common.OidcConfig",
                "inherits": [
                    "io.helidon.security.providers.oidc.common.BaseBuilder"
                ],
                "producers": [
                    "io.helidon.security.providers.oidc.common.OidcConfig.Builder#build()",
                    "io.helidon.security.providers.oidc.common.OidcConfig#create(io.helidon.common.config.Config)"
                ],
                "options": [
                    {
                        "defaultValue": "true",
                        "description": "Whether to encrypt state cookie created by this microservice.\n Defaults to `true`.",
                        "key": "cookie-encryption-state-enabled",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#cookieEncryptionEnabledState(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Configurations of the tenants",
                        "key": "tenants",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#addTenantConfig(io.helidon.security.providers.oidc.common.TenantConfig)",
                        "type": "io.helidon.security.providers.oidc.common.TenantConfig"
                    },
                    {
                        "defaultValue": "/oidc/redirect",
                        "description": "URI to register web server component on, used by the OIDC server to\n redirect authorization requests to after a user logs in or approves\n scopes.\n Note that usually the redirect URI configured here must be the\n same one as configured on OIDC server.\n\n <p>\n Defaults to {@value #DEFAULT_REDIRECT_URI}",
                        "key": "redirect-uri",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#redirectUri(java.lang.String)"
                    },
                    {
                        "defaultValue": "false",
                        "description": "Can be set to `true` to force the use of relative URIs in all requests,\n regardless of the presence or absence of proxies or no-proxy lists. By default,\n requests that use the Proxy will have absolute URIs. Set this flag to `true`\n if the host is unable to accept absolute URIs.\n Defaults to {@value #DEFAULT_RELATIVE_URIS}.",
                        "key": "relative-uris",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#relativeUris(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Master password for encryption/decryption of cookies. This must be configured to the same value on each microservice\n using the cookie.",
                        "key": "cookie-encryption-password",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#cookieEncryptionPassword(char[])",
                        "type": "char[]"
                    },
                    {
                        "defaultValue": "/",
                        "description": "Path the cookie is valid for.\n Defaults to \"/\".",
                        "key": "cookie-path",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#cookiePath(java.lang.String)"
                    },
                    {
                        "description": "When using cookie, used to set MaxAge attribute of the cookie, defining how long\n the cookie is valid.\n Not used by default.",
                        "key": "cookie-max-age-seconds",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#cookieMaxAgeSeconds(long)",
                        "type": "java.lang.Long"
                    },
                    {
                        "defaultValue": "false",
                        "description": "By default, the client should redirect to the identity server for the user to log in.\n This behavior can be overridden by setting redirect to false. When token is not present in the request, the client\n will not redirect and just return appropriate error response code.",
                        "key": "redirect",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#redirect(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Proxy host to use. When defined, triggers usage of proxy for HTTP requests.\n Setting to empty String has the same meaning as setting to null - disables proxy.",
                        "key": "proxy-host",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#proxyHost(java.lang.String)"
                    },
                    {
                        "defaultValue": "false",
                        "description": "Whether to use a query parameter to send JWT token from application to this\n server.",
                        "key": "query-param-use",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#useParam(java.lang.Boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "HELIDON_TENANT",
                        "description": "The name of the cookie to use for the tenant name.\n Defaults to {@value #DEFAULT_TENANT_COOKIE_NAME}.",
                        "key": "cookie-name-tenant",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#cookieTenantName(java.lang.String)"
                    },
                    {
                        "defaultValue": "80",
                        "description": "Proxy port.\n Defaults to {@value DEFAULT_PROXY_PORT}",
                        "key": "proxy-port",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#proxyPort(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "description": "Domain the cookie is valid for.\n Not used by default.",
                        "key": "cookie-domain",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#cookieDomain(java.lang.String)"
                    },
                    {
                        "defaultValue": "http",
                        "description": "Proxy protocol to use when proxy is used.\n Defaults to {@value DEFAULT_PROXY_PROTOCOL}.",
                        "key": "proxy-protocol",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#proxyProtocol(java.lang.String)"
                    },
                    {
                        "defaultValue": "false",
                        "description": "Whether to encrypt token cookie created by this microservice.\n Defaults to `false`.",
                        "key": "cookie-encryption-enabled",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#cookieEncryptionEnabled(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "5",
                        "description": "Configure maximal number of redirects when redirecting to an OIDC provider within a single authentication\n attempt.\n <p>\n Defaults to {@value #DEFAULT_MAX_REDIRECTS}",
                        "key": "max-redirects",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#maxRedirects(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "description": "Name of the encryption configuration available through Security#encrypt(String, byte[]) and\n Security#decrypt(String, String).\n If configured and encryption is enabled for any cookie,\n Security MUST be configured in global or current `io.helidon.common.context.Context` (this\n is done automatically in Helidon MP).",
                        "key": "cookie-encryption-name",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#cookieEncryptionName(java.lang.String)"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether id token signature check should be enabled.\n Signature check is enabled by default, and it is highly recommended to not change that.\n Change this setting only when you really know what you are doing, otherwise it could case security issues.",
                        "key": "id-token-signature-validation",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#idTokenSignatureValidation(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Full URI of this application that is visible from user browser.\n Used to redirect request back from identity server after successful login.",
                        "key": "frontend-uri",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#frontendUri(java.lang.String)"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether to check if current IP address matches the one access token was issued for.\n This check helps with cookie replay attack prevention.",
                        "key": "access-token-ip-check",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#accessTokenIpCheck(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "h_ra",
                        "description": "Configure the parameter used to store the number of attempts in redirect.\n <p>\n Defaults to {@value #DEFAULT_ATTEMPT_PARAM}",
                        "key": "redirect-attempt-param",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#redirectAttemptParam(java.lang.String)"
                    },
                    {
                        "defaultValue": "LAX",
                        "description": "When using cookie, used to set the SameSite cookie value. Can be\n \"Strict\" or \"Lax\".",
                        "key": "cookie-same-site",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#cookieSameSite(io.helidon.http.SetCookie.SameSite)",
                        "type": "io.helidon.http.SetCookie.SameSite",
                        "allowedValues": [
                            {
                                "description": "",
                                "value": "LAX"
                            },
                            {
                                "description": "",
                                "value": "STRICT"
                            },
                            {
                                "description": "",
                                "value": "NONE"
                            }
                        ]
                    },
                    {
                        "defaultValue": "accessToken",
                        "description": "Name of a query parameter that contains the JWT access token when parameter is used.",
                        "key": "query-param-name",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#paramName(java.lang.String)"
                    },
                    {
                        "description": "Assign cross-origin resource sharing settings.",
                        "key": "cors",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#crossOriginConfig(io.helidon.cors.CrossOriginConfig)",
                        "type": "io.helidon.cors.CrossOriginConfig"
                    },
                    {
                        "defaultValue": "false",
                        "description": "Force HTTPS for redirects to identity provider.\n Defaults to `false`.",
                        "key": "force-https-redirects",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#forceHttpsRedirects(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "id_token",
                        "description": "Name of a query parameter that contains the JWT id token when parameter is used.",
                        "key": "query-id-token-param-name",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#idTokenParamName(java.lang.String)"
                    },
                    {
                        "defaultValue": "JSESSIONID_3",
                        "description": "The name of the cookie to use for the state storage.\n Defaults to {@value #DEFAULT_STATE_COOKIE_NAME}.",
                        "key": "cookie-name-state",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#cookieNameState(java.lang.String)"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether to encrypt refresh token cookie created by this microservice.\n Defaults to `true`.",
                        "key": "cookie-encryption-refresh-enabled",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#cookieEncryptionEnabledRefreshToken(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "true",
                        "description": "When using cookie, if set to true, the HttpOnly attribute will be configured.\n Defaults to {@value OidcCookieHandler.Builder#DEFAULT_HTTP_ONLY}.",
                        "key": "cookie-http-only",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#cookieHttpOnly(java.lang.Boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "A TokenHandler to\n process header containing a JWT.\n Default is \"Authorization\" header with a prefix \"bearer \".",
                        "key": "header-token",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#headerTokenHandler(io.helidon.security.util.TokenHandler)",
                        "type": "io.helidon.security.util.TokenHandler"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether to expect JWT in a header field.",
                        "key": "header-use",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#useHeader(java.lang.Boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "false",
                        "description": "When using cookie, if set to true, the Secure attribute will be configured.\n Defaults to false.",
                        "key": "cookie-secure",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#cookieSecure(java.lang.Boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether to encrypt tenant name cookie created by this microservice.\n Defaults to `true`.",
                        "key": "cookie-encryption-tenant-enabled",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#cookieEncryptionEnabledTenantName(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether access token signature check should be enabled.\n Signature check is enabled by default, and it is highly recommended to not change that.\n Change this setting only when you really know what you are doing, otherwise it could case security issues.",
                        "key": "token-signature-validation",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#tokenSignatureValidation(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "JSESSIONID",
                        "description": "Name of the cookie to use.\n Defaults to {@value #DEFAULT_COOKIE_NAME}.",
                        "key": "cookie-name",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#cookieName(java.lang.String)"
                    },
                    {
                        "defaultValue": "h_tenant",
                        "description": "Name of a query parameter that contains the tenant name when the parameter is used.\n Defaults to #DEFAULT_TENANT_PARAM_NAME.",
                        "key": "query-param-tenant-name",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#paramTenantName(java.lang.String)"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether to encrypt id token cookie created by this microservice.\n Defaults to `true`.",
                        "key": "cookie-encryption-id-enabled",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#cookieEncryptionEnabledIdToken(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "JSESSIONID_2",
                        "description": "Name of the cookie to use for id token.\n Defaults to {@value #DEFAULT_COOKIE_NAME}_2.\n\n This cookie is only used when logout is enabled, as otherwise it is not needed.\n Content of this cookie is encrypted.",
                        "key": "cookie-name-id-token",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#cookieNameIdToken(java.lang.String)"
                    },
                    {
                        "defaultValue": "JSESSIONID_3",
                        "description": "The name of the cookie to use for the refresh token.\n Defaults to {@value #DEFAULT_REFRESH_COOKIE_NAME}.",
                        "key": "cookie-name-refresh-token",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#cookieNameRefreshToken(java.lang.String)"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether to use cookie to store JWT between requests.\n Defaults to {@value #DEFAULT_COOKIE_USE}.",
                        "key": "cookie-use",
                        "method": "io.helidon.security.providers.oidc.common.OidcConfig.Builder#useCookie(java.lang.Boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.security.providers.oidc.common.TenantConfig.Builder",
                "description": "Open ID Connect tenant configuration",
                "type": "io.helidon.security.providers.oidc.common.TenantConfig",
                "inherits": [
                    "io.helidon.security.providers.oidc.common.BaseBuilder"
                ],
                "producers": [
                    "io.helidon.security.providers.oidc.common.TenantConfig.Builder#build()"
                ],
                "options": [
                    {
                        "description": "Name of the tenant.",
                        "key": "name",
                        "method": "io.helidon.security.providers.oidc.common.TenantConfig.Builder#name(java.lang.String)",
                        "required": true
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.security.providers.oidc.common.BaseBuilder",
                "type": "io.helidon.security.providers.oidc.common.BaseBuilder",
                "options": [
                    {
                        "description": "URI of the identity server, base used to retrieve OIDC metadata.",
                        "key": "identity-uri",
                        "method": "io.helidon.security.providers.oidc.common.BaseBuilder#identityUri(java.net.URI)",
                        "type": "java.net.URI"
                    },
                    {
                        "description": "Resource configuration for OIDC Metadata\n containing endpoints to various identity services, as well as information about the identity server.",
                        "key": "oidc-metadata.resource",
                        "method": "io.helidon.security.providers.oidc.common.BaseBuilder#oidcMetadata(io.helidon.common.configurable.Resource)",
                        "type": "io.helidon.common.configurable.Resource"
                    },
                    {
                        "description": "Endpoint to use to validate JWT.\n Either use this or set #signJwk(JwkKeys) or #signJwk(Resource).",
                        "key": "introspect-endpoint-uri",
                        "method": "io.helidon.security.providers.oidc.common.BaseBuilder#introspectEndpointUri(java.net.URI)",
                        "type": "java.net.URI"
                    },
                    {
                        "defaultValue": "false",
                        "description": "Allow audience claim to be optional.",
                        "key": "optional-audience",
                        "method": "io.helidon.security.providers.oidc.common.BaseBuilder#optionalAudience(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Audience of issued tokens.",
                        "key": "audience",
                        "method": "io.helidon.security.providers.oidc.common.BaseBuilder#audience(java.lang.String)"
                    },
                    {
                        "defaultValue": "30000",
                        "description": "Timeout of calls using web client.",
                        "key": "client-timeout-millis",
                        "method": "io.helidon.security.providers.oidc.common.BaseBuilder#clientTimeout(java.time.Duration)",
                        "type": "java.time.Duration"
                    },
                    {
                        "description": "A resource pointing to JWK with public keys of signing certificates used\n to validate JWT.",
                        "key": "sign-jwk.resource",
                        "method": "io.helidon.security.providers.oidc.common.BaseBuilder#signJwk(io.helidon.common.configurable.Resource)",
                        "type": "io.helidon.common.configurable.Resource"
                    },
                    {
                        "defaultValue": "openid",
                        "description": "Configure base scopes.\n By default, this is {@value #DEFAULT_BASE_SCOPES}.\n If scope has a qualifier, it must be used here.",
                        "key": "base-scopes",
                        "method": "io.helidon.security.providers.oidc.common.BaseBuilder#baseScopes(java.lang.String)"
                    },
                    {
                        "defaultValue": "@default",
                        "description": "Configure one of the supported types of identity servers.\n\n If the type does not have an explicit mapping, a warning is logged and the default implementation is used.",
                        "key": "server-type",
                        "method": "io.helidon.security.providers.oidc.common.BaseBuilder#serverType(java.lang.String)"
                    },
                    {
                        "description": "Issuer of issued tokens.",
                        "key": "issuer",
                        "method": "io.helidon.security.providers.oidc.common.BaseBuilder#issuer(java.lang.String)"
                    },
                    {
                        "defaultValue": "false",
                        "description": "Configure audience claim check.",
                        "key": "check-audience",
                        "method": "io.helidon.security.providers.oidc.common.BaseBuilder#checkAudience(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Use JWK (a set of keys to validate signatures of JWT) to validate tokens.\n Use this method when you want to use default values for JWK or introspection endpoint URI.",
                        "key": "validate-jwt-with-jwk",
                        "method": "io.helidon.security.providers.oidc.common.BaseBuilder#validateJwtWithJwk(java.lang.Boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "true",
                        "description": "If set to true, metadata will be loaded from default (well known)\n location, unless it is explicitly defined using oidc-metadata-resource. If set to false, it would not be loaded\n even if oidc-metadata-resource is not defined. In such a case all URIs must be explicitly defined (e.g.\n token-endpoint-uri).",
                        "key": "oidc-metadata-well-known",
                        "method": "io.helidon.security.providers.oidc.common.BaseBuilder#oidcMetadataWellKnown(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Client secret as generated by OIDC server.\n Used to authenticate this application with the server when requesting\n JWT based on a code.",
                        "key": "client-secret",
                        "method": "io.helidon.security.providers.oidc.common.BaseBuilder#clientSecret(java.lang.String)"
                    },
                    {
                        "description": "Audience of the scope required by this application. This is prefixed to\n the scope name when requesting scopes from the identity server.\n Defaults to empty string.",
                        "key": "scope-audience",
                        "method": "io.helidon.security.providers.oidc.common.BaseBuilder#scopeAudience(java.lang.String)"
                    },
                    {
                        "defaultValue": "CLIENT_SECRET_BASIC",
                        "description": "Type of authentication to use when invoking the token endpoint.\n Current supported options:\n <ul>\n     <li>io.helidon.security.providers.oidc.common.OidcConfig.ClientAuthentication#CLIENT_SECRET_BASIC</li>\n     <li>io.helidon.security.providers.oidc.common.OidcConfig.ClientAuthentication#CLIENT_SECRET_POST</li>\n     <li>io.helidon.security.providers.oidc.common.OidcConfig.ClientAuthentication#NONE</li>\n </ul>",
                        "key": "token-endpoint-auth",
                        "method": "io.helidon.security.providers.oidc.common.BaseBuilder#tokenEndpointAuthentication(io.helidon.security.providers.oidc.common.OidcConfig.ClientAuthentication)",
                        "type": "io.helidon.security.providers.oidc.common.OidcConfig.ClientAuthentication",
                        "allowedValues": [
                            {
                                "description": "Clients that have received a client_secret value from the Authorization Server authenticate with the Authorization\n Server in accordance with Section 2.3.1 of OAuth 2.0 [RFC6749] using the HTTP Basic authentication scheme.\n This is the default client authentication.",
                                "value": "CLIENT_SECRET_BASIC"
                            },
                            {
                                "description": "Clients that have received a client_secret value from the Authorization Server, authenticate with the Authorization\n Server in accordance with Section 2.3.1 of OAuth 2.0 [RFC6749] by including the Client Credentials in the request body.",
                                "value": "CLIENT_SECRET_POST"
                            },
                            {
                                "description": "Clients that have received a client_secret value from the Authorization Server create a JWT using an HMAC SHA\n algorithm, such as HMAC SHA-256. The HMAC (Hash-based Message Authentication Code) is calculated using the octets of\n the UTF-8 representation of the client_secret as the shared key.\n The Client authenticates in accordance with JSON Web Token (JWT) Profile for OAuth 2.0 Client Authentication and\n Authorization Grants [OAuth.JWT] and Assertion Framework for OAuth 2.0 Client Authentication and Authorization\n Grants [OAuth.Assertions].\n <p>\n The JWT MUST contain the following REQUIRED Claim Values and MAY contain the following\n OPTIONAL Claim Values.\n <p>\n Required:\n `iss, sub, aud, jti, exp`\n <p>\n Optional:\n `iat`",
                                "value": "CLIENT_SECRET_JWT"
                            },
                            {
                                "description": "Clients that have registered a public key sign a JWT using that key. The Client authenticates in accordance with\n JSON Web Token (JWT) Profile for OAuth 2.0 Client Authentication and Authorization Grants [OAuth.JWT] and Assertion\n Framework for OAuth 2.0 Client Authentication and Authorization Grants [OAuth.Assertions].\n <p>\n The JWT MUST contain the following REQUIRED Claim Values and MAY contain the following\n OPTIONAL Claim Values.\n <p>\n Required:\n `iss, sub, aud, jti, exp`\n <p>\n Optional:\n `iat`",
                                "value": "PRIVATE_KEY_JWT"
                            },
                            {
                                "description": "The Client does not authenticate itself at the Token Endpoint, either because it uses only the Implicit Flow (and so\n does not use the Token Endpoint) or because it is a Public Client with no Client Secret or other authentication\n mechanism.",
                                "value": "NONE"
                            }
                        ]
                    },
                    {
                        "description": "Client ID as generated by OIDC server.",
                        "key": "client-id",
                        "method": "io.helidon.security.providers.oidc.common.BaseBuilder#clientId(java.lang.String)"
                    },
                    {
                        "description": "URI of an authorization endpoint used to redirect users to for logging-in.\n\n If not defined, it is obtained from #oidcMetadata(Resource), if that is not defined\n an attempt is made to use #identityUri(URI)/oauth2/v1/authorize.",
                        "key": "authorization-endpoint-uri",
                        "method": "io.helidon.security.providers.oidc.common.BaseBuilder#authorizationEndpointUri(java.net.URI)",
                        "type": "java.net.URI"
                    },
                    {
                        "description": "URI of a token endpoint used to obtain a JWT based on the authentication\n code.\n If not defined, it is obtained from #oidcMetadata(Resource), if that is not defined\n an attempt is made to use #identityUri(URI)/oauth2/v1/token.",
                        "key": "token-endpoint-uri",
                        "method": "io.helidon.security.providers.oidc.common.BaseBuilder#tokenEndpointUri(java.net.URI)",
                        "type": "java.net.URI"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.security.providers.idcs.mapper",
        "types": [
            {
                "annotatedType": "io.helidon.security.providers.idcs.mapper.IdcsMtRoleMapperProvider.Builder",
                "description": "Multitenant IDCS role mapping provider",
                "prefix": "idcs-role-mapper",
                "type": "io.helidon.security.providers.idcs.mapper.IdcsMtRoleMapperProvider",
                "inherits": [
                    "io.helidon.security.providers.idcs.mapper.IdcsRoleMapperProviderBase.Builder"
                ],
                "producers": [
                    "io.helidon.security.providers.idcs.mapper.IdcsMtRoleMapperProvider.Builder#build()",
                    "io.helidon.security.providers.idcs.mapper.IdcsMtRoleMapperProvider#create(io.helidon.common.config.Config)"
                ],
                "provides": [
                    "io.helidon.security.spi.SecurityProvider",
                    "io.helidon.security.spi.SubjectMappingProvider"
                ],
                "options": [
                    {
                        "description": "Use explicit io.helidon.security.providers.common.EvictableCache for role caching.",
                        "key": "cache-config",
                        "method": "io.helidon.security.providers.idcs.mapper.IdcsMtRoleMapperProvider.Builder#cache(io.helidon.security.providers.common.EvictableCache<io.helidon.security.providers.idcs.mapper.IdcsMtRoleMapperProvider.MtCacheKey, java.util.List<io.helidon.security.Grant>>)",
                        "type": "io.helidon.security.providers.common.EvictableCache"
                    },
                    {
                        "description": "Configure token handler for IDCS Application name.\n By default the header {@value IdcsMtRoleMapperProvider#IDCS_APP_HEADER} is used.",
                        "key": "idcs-app-name-handler",
                        "method": "io.helidon.security.providers.idcs.mapper.IdcsMtRoleMapperProvider.Builder#idcsAppNameTokenHandler(io.helidon.security.util.TokenHandler)",
                        "type": "io.helidon.security.util.TokenHandler"
                    },
                    {
                        "description": "Configure token handler for IDCS Tenant ID.\n By default the header {@value IdcsMtRoleMapperProvider#IDCS_TENANT_HEADER} is used.",
                        "key": "idcs-tenant-handler",
                        "method": "io.helidon.security.providers.idcs.mapper.IdcsMtRoleMapperProvider.Builder#idcsTenantTokenHandler(io.helidon.security.util.TokenHandler)",
                        "type": "io.helidon.security.util.TokenHandler"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.security.providers.idcs.mapper.IdcsRoleMapperProviderBase.Builder",
                "type": "io.helidon.security.providers.idcs.mapper.IdcsRoleMapperProviderBase.Builder",
                "options": [
                    {
                        "description": "Use explicit io.helidon.security.providers.oidc.common.OidcConfig instance, e.g. when using it also for OIDC\n provider.",
                        "key": "oidc-config",
                        "method": "io.helidon.security.providers.idcs.mapper.IdcsRoleMapperProviderBase.Builder#oidcConfig(io.helidon.security.providers.oidc.common.OidcConfig)",
                        "type": "io.helidon.security.providers.oidc.common.OidcConfig"
                    },
                    {
                        "defaultValue": "user",
                        "description": "Configure subject type to use when requesting roles from IDCS.\n Can be either #IDCS_SUBJECT_TYPE_USER or #IDCS_SUBJECT_TYPE_CLIENT.\n Defaults to #IDCS_SUBJECT_TYPE_USER.",
                        "key": "default-idcs-subject-type",
                        "method": "io.helidon.security.providers.idcs.mapper.IdcsRoleMapperProviderBase.Builder#defaultIdcsSubjectType(java.lang.String)"
                    },
                    {
                        "defaultValue": "USER",
                        "description": "Add a supported subject type.\n If none added, io.helidon.security.SubjectType#USER is used.\n If any added, only the ones added will be used (e.g. if you want to use\n both io.helidon.security.SubjectType#USER and io.helidon.security.SubjectType#SERVICE,\n both need to be added.",
                        "key": "subject-types",
                        "kind": "LIST",
                        "method": "io.helidon.security.providers.idcs.mapper.IdcsRoleMapperProviderBase.Builder#addSubjectType(io.helidon.security.SubjectType)",
                        "type": "io.helidon.security.SubjectType",
                        "allowedValues": [
                            {
                                "description": "",
                                "value": "USER"
                            },
                            {
                                "description": "",
                                "value": "SERVICE"
                            }
                        ]
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.security.providers.idcs.mapper.IdcsRoleMapperProvider.Builder",
                "description": "IDCS role mapping provider",
                "prefix": "idcs-role-mapper",
                "type": "io.helidon.security.providers.idcs.mapper.IdcsRoleMapperProvider",
                "inherits": [
                    "io.helidon.security.providers.idcs.mapper.IdcsRoleMapperProviderBase.Builder"
                ],
                "producers": [
                    "io.helidon.security.providers.idcs.mapper.IdcsRoleMapperProvider.Builder#build()",
                    "io.helidon.security.providers.idcs.mapper.IdcsRoleMapperProvider#create(io.helidon.common.config.Config)"
                ],
                "provides": [
                    "io.helidon.security.spi.SecurityProvider",
                    "io.helidon.security.spi.SubjectMappingProvider"
                ],
                "options": [
                    {
                        "description": "Use explicit io.helidon.security.providers.common.EvictableCache for role caching.",
                        "key": "cache-config",
                        "method": "io.helidon.security.providers.idcs.mapper.IdcsRoleMapperProvider.Builder#roleCache(io.helidon.security.providers.common.EvictableCache<java.lang.String, java.util.List<io.helidon.security.Grant>>)",
                        "type": "io.helidon.security.providers.common.EvictableCache"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.security.providers.oidc",
        "types": [
            {
                "annotatedType": "io.helidon.security.providers.oidc.OidcProvider.Builder",
                "description": "Open ID Connect security provider",
                "prefix": "oidc",
                "type": "io.helidon.security.providers.oidc.OidcProvider",
                "producers": [
                    "io.helidon.security.providers.oidc.OidcProvider.Builder#build()",
                    "io.helidon.security.providers.oidc.OidcProvider#create(io.helidon.common.config.Config)"
                ],
                "provides": [
                    "io.helidon.security.spi.AuthenticationProvider",
                    "io.helidon.security.spi.SecurityProvider"
                ],
                "options": [
                    {
                        "description": "Configuration of outbound rules.",
                        "key": "outbound-config",
                        "method": "io.helidon.security.providers.oidc.OidcProvider.Builder#outboundConfig(io.helidon.security.providers.common.OutboundConfig)",
                        "type": "io.helidon.security.providers.common.OutboundConfig",
                        "merge": true
                    },
                    {
                        "description": "Configuration of OIDC (Open ID Connect).",
                        "key": "oidc-config",
                        "method": "io.helidon.security.providers.oidc.OidcProvider.Builder#oidcConfig(io.helidon.security.providers.oidc.common.OidcConfig)",
                        "type": "io.helidon.security.providers.oidc.common.OidcConfig",
                        "merge": true
                    },
                    {
                        "defaultValue": "false",
                        "description": "Whether authentication is required.\n By default, request will fail if the authentication cannot be verified.\n If set to true, request will process and this provider will abstain.",
                        "key": "optional",
                        "method": "io.helidon.security.providers.oidc.OidcProvider.Builder#optional(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Claim `groups` from JWT will be used to automatically add\n  groups to current subject (may be used with jakarta.annotation.security.RolesAllowed annotation).",
                        "key": "use-jwt-groups",
                        "method": "io.helidon.security.providers.oidc.OidcProvider.Builder#useJwtGroups(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "false",
                        "description": "Whether to propagate identity.",
                        "key": "propagate",
                        "method": "io.helidon.security.providers.oidc.OidcProvider.Builder#propagate(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.security.providers.abac",
        "types": [
            {
                "annotatedType": "io.helidon.security.providers.abac.AbacProvider.Builder",
                "description": "Attribute Based Access Control provider",
                "prefix": "abac",
                "type": "io.helidon.security.providers.abac.AbacProvider",
                "producers": [
                    "io.helidon.security.providers.abac.AbacProvider.Builder#build()",
                    "io.helidon.security.providers.abac.AbacProvider#create(io.helidon.common.config.Config)"
                ],
                "provides": [
                    "io.helidon.security.spi.SecurityProvider",
                    "io.helidon.security.spi.AuthorizationProvider"
                ],
                "options": [
                    {
                        "defaultValue": "true",
                        "description": "Whether to fail if any attribute is left unvalidated.",
                        "key": "fail-on-unvalidated",
                        "method": "io.helidon.security.providers.abac.AbacProvider.Builder#failOnUnvalidated(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether to fail if NONE of the attributes is validated.",
                        "key": "fail-if-none-validated",
                        "method": "io.helidon.security.providers.abac.AbacProvider.Builder#failIfNoneValidated(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.security.providers.common",
        "types": [
            {
                "annotatedType": "io.helidon.security.providers.common.OutboundConfig.Builder",
                "description": "Outbound configuration for outbound security",
                "type": "io.helidon.security.providers.common.OutboundConfig",
                "producers": [
                    "io.helidon.security.providers.common.OutboundConfig.Builder#build()",
                    "io.helidon.security.providers.common.OutboundConfig#create(io.helidon.common.config.Config)"
                ],
                "options": [
                    {
                        "description": "Add a new target configuration.",
                        "key": "outbound",
                        "kind": "LIST",
                        "method": "io.helidon.security.providers.common.OutboundConfig.Builder#addTarget(io.helidon.security.providers.common.OutboundTarget)",
                        "type": "io.helidon.security.providers.common.OutboundTarget"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.security.providers.common.EvictableCache.Builder",
                "type": "io.helidon.security.providers.common.EvictableCache",
                "producers": [
                    "io.helidon.security.providers.common.EvictableCache.Builder#build()",
                    "io.helidon.security.providers.common.EvictableCache#create(io.helidon.common.config.Config)"
                ],
                "options": [
                    {
                        "defaultValue": "true",
                        "description": "If the cacheEnabled is set to false, no caching will be done.\n Otherwise (default behavior) evictable caching will be used.",
                        "key": "cache-enabled",
                        "method": "io.helidon.security.providers.common.EvictableCache.Builder#cacheEnabled(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Configure evictor to check if a record is still valid.\n This should be a fast way to check, as it is happening in a ConcurrentHashMap#forEachKey(long, Consumer).\n This is also called during all get and remove operations to only return valid records.",
                        "key": "evictor-class",
                        "method": "io.helidon.security.providers.common.EvictableCache.Builder#evictor(java.util.function.BiFunction<K, V, java.lang.Boolean>)",
                        "type": "java.lang.Class"
                    },
                    {
                        "defaultValue": "10000",
                        "description": "Configure parallelism threshold.",
                        "key": "parallelism-threshold",
                        "method": "io.helidon.security.providers.common.EvictableCache.Builder#parallelismThreshold(long)",
                        "type": "java.lang.Long"
                    },
                    {
                        "defaultValue": "3600000",
                        "description": "Configure record timeout since last access.",
                        "key": "cache-timeout-millis",
                        "method": "io.helidon.security.providers.common.EvictableCache.Builder#timeout(long, java.util.concurrent.TimeUnit)",
                        "type": "java.lang.Long"
                    },
                    {
                        "defaultValue": "60000",
                        "description": "Delay from the creation of the cache to first eviction",
                        "key": "cache-evict-delay-millis",
                        "method": "io.helidon.security.providers.common.EvictableCache.Builder#evictSchedule(long, long, java.util.concurrent.TimeUnit)",
                        "type": "java.lang.Long"
                    },
                    {
                        "defaultValue": "300000",
                        "description": "How often to evict records",
                        "key": "cache-evict-period-millis",
                        "method": "io.helidon.security.providers.common.EvictableCache.Builder#evictSchedule(long, long, java.util.concurrent.TimeUnit)",
                        "type": "java.lang.Long"
                    },
                    {
                        "defaultValue": "100000",
                        "description": "Configure maximal cache size.",
                        "key": "max-size",
                        "method": "io.helidon.security.providers.common.EvictableCache.Builder#maxSize(long)",
                        "type": "java.lang.Long"
                    },
                    {
                        "defaultValue": "3600000",
                        "description": "Configure record timeout since its creation.",
                        "key": "cache-overall-timeout-millis",
                        "method": "io.helidon.security.providers.common.EvictableCache.Builder#overallTimeout(long, java.util.concurrent.TimeUnit)",
                        "type": "java.lang.Long"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.security.providers.common.OutboundTarget.Builder",
                "type": "io.helidon.security.providers.common.OutboundTarget",
                "producers": [
                    "io.helidon.security.providers.common.OutboundTarget.Builder#build()",
                    "io.helidon.security.providers.common.OutboundTarget#create(io.helidon.common.config.Config)"
                ],
                "options": [
                    {
                        "description": "Add supported paths for this target. May be called more than once to add more paths.\n The path is tested as is against called path, and also tested as a regular expression.",
                        "key": "paths",
                        "kind": "LIST",
                        "method": "io.helidon.security.providers.common.OutboundTarget.Builder#addPath(java.lang.String)"
                    },
                    {
                        "description": "Add supported method for this target. May be called more than once to add more methods.\n The method is tested as is ignoring case against the used method.",
                        "key": "methods",
                        "kind": "LIST",
                        "method": "io.helidon.security.providers.common.OutboundTarget.Builder#addMethod(java.lang.String)"
                    },
                    {
                        "description": "Add supported host for this target. May be called more than once to add more hosts.\n <p>\n Valid examples:\n <ul>\n <li>localhost\n <li>www.google.com\n <li>127.0.0.1\n <li>*.oracle.com\n <li>192.169.*.*\n <li>*.google.*\n </ul>",
                        "key": "hosts",
                        "kind": "LIST",
                        "method": "io.helidon.security.providers.common.OutboundTarget.Builder#addHost(java.lang.String)"
                    },
                    {
                        "description": "Configure the name of this outbound target.",
                        "key": "name",
                        "method": "io.helidon.security.providers.common.OutboundTarget.Builder#name(java.lang.String)",
                        "required": true
                    },
                    {
                        "description": "Add supported transports for this target. May be called more than once to add more transports.\n <p>\n Valid examples:\n <ul>\n <li>http\n <li>https\n </ul>\n There is no wildcard support",
                        "key": "transport",
                        "kind": "LIST",
                        "method": "io.helidon.security.providers.common.OutboundTarget.Builder#addTransport(java.lang.String)"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.security.providers.google.login",
        "types": [
            {
                "annotatedType": "io.helidon.security.providers.google.login.GoogleTokenProvider.Builder",
                "description": "Google Authentication provider",
                "prefix": "google-login",
                "type": "io.helidon.security.providers.google.login.GoogleTokenProvider",
                "producers": [
                    "io.helidon.security.providers.google.login.GoogleTokenProvider.Builder#build()",
                    "io.helidon.security.providers.google.login.GoogleTokenProvider#create(io.helidon.common.config.Config)"
                ],
                "provides": [
                    "io.helidon.security.spi.SecurityProvider",
                    "io.helidon.security.spi.AuthenticationProvider"
                ],
                "options": [
                    {
                        "defaultValue": "false",
                        "description": "If set to true, this provider will return io.helidon.security.SecurityResponse.SecurityStatus#ABSTAIN instead\n of failing in case of invalid request.",
                        "key": "optional",
                        "method": "io.helidon.security.providers.google.login.GoogleTokenProvider.Builder#optional(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Set proxy host when talking to Google.",
                        "key": "proxy-host",
                        "method": "io.helidon.security.providers.google.login.GoogleTokenProvider.Builder#proxyHost(java.lang.String)"
                    },
                    {
                        "description": "Outbound configuration - a set of outbound targets that\n will have the token propagated.",
                        "key": "outbound",
                        "method": "io.helidon.security.providers.google.login.GoogleTokenProvider.Builder#outboundConfig(io.helidon.security.providers.common.OutboundConfig)",
                        "type": "io.helidon.security.providers.common.OutboundConfig"
                    },
                    {
                        "defaultValue": "helidon",
                        "description": "Set the authentication realm to build challenge, defaults to \"helidon\".",
                        "key": "realm",
                        "method": "io.helidon.security.providers.google.login.GoogleTokenProvider.Builder#realm(java.lang.String)"
                    },
                    {
                        "description": "Google application client id, to validate that the token was generated by Google for us.",
                        "key": "client-id",
                        "method": "io.helidon.security.providers.google.login.GoogleTokenProvider.Builder#clientId(java.lang.String)"
                    },
                    {
                        "defaultValue": "80",
                        "description": "Set proxy port when talking to Google.",
                        "key": "proxy-port",
                        "method": "io.helidon.security.providers.google.login.GoogleTokenProvider.Builder#proxyPort(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "`Authorization` header with `bearer` prefix",
                        "description": "Token provider to extract Google access token from request, defaults to \"Authorization\" header with a \"bearer \" prefix.",
                        "key": "token",
                        "method": "io.helidon.security.providers.google.login.GoogleTokenProvider.Builder#tokenProvider(io.helidon.security.util.TokenHandler)",
                        "type": "io.helidon.security.util.TokenHandler"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.security.providers.httpauth",
        "types": [
            {
                "annotatedType": "io.helidon.security.providers.httpauth.ConfigUserStore.ConfigUser",
                "type": "io.helidon.security.providers.httpauth.ConfigUserStore.ConfigUser",
                "producers": [
                    "io.helidon.security.providers.httpauth.ConfigUserStore.ConfigUser#create(io.helidon.common.config.Config)"
                ],
                "options": [
                    {
                        "description": "User's password",
                        "key": "password"
                    },
                    {
                        "description": "List of roles the user is in",
                        "key": "roles",
                        "kind": "LIST"
                    },
                    {
                        "description": "User's login",
                        "key": "login"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.security.providers.httpauth.HttpBasicAuthProvider.Builder",
                "description": "HTTP Basic Authentication provider",
                "prefix": "http-basic-auth",
                "type": "io.helidon.security.providers.httpauth.HttpBasicAuthProvider",
                "producers": [
                    "io.helidon.security.providers.httpauth.HttpBasicAuthProvider.Builder#build()",
                    "io.helidon.security.providers.httpauth.HttpBasicAuthProvider#create(io.helidon.common.config.Config)"
                ],
                "provides": [
                    "io.helidon.security.spi.SecurityProvider",
                    "io.helidon.security.spi.AuthenticationProvider"
                ],
                "options": [
                    {
                        "description": "Set user store to validate users.\n Removes any other stores added through #addUserStore(SecureUserStore).",
                        "key": "users",
                        "kind": "LIST",
                        "method": "io.helidon.security.providers.httpauth.HttpBasicAuthProvider.Builder#userStore(io.helidon.security.providers.httpauth.SecureUserStore)",
                        "type": "io.helidon.security.providers.httpauth.ConfigUserStore.ConfigUser"
                    },
                    {
                        "defaultValue": "false",
                        "description": "Whether authentication is required.\n By default, request will fail if the authentication cannot be verified.\n If set to false, request will process and this provider will abstain.",
                        "key": "optional",
                        "method": "io.helidon.security.providers.httpauth.HttpBasicAuthProvider.Builder#optional(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Add a new outbound target to configure identity propagation or explicit username/password.",
                        "key": "outbound",
                        "kind": "LIST",
                        "method": "io.helidon.security.providers.httpauth.HttpBasicAuthProvider.Builder#addOutboundTarget(io.helidon.security.providers.common.OutboundTarget)",
                        "type": "io.helidon.security.providers.common.OutboundTarget"
                    },
                    {
                        "defaultValue": "helidon",
                        "description": "Set the realm to use when challenging users.",
                        "key": "realm",
                        "method": "io.helidon.security.providers.httpauth.HttpBasicAuthProvider.Builder#realm(java.lang.String)"
                    },
                    {
                        "defaultValue": "USER",
                        "description": "Principal type this provider extracts (and also propagates).",
                        "key": "principal-type",
                        "method": "io.helidon.security.providers.httpauth.HttpBasicAuthProvider.Builder#subjectType(io.helidon.security.SubjectType)",
                        "type": "io.helidon.security.SubjectType",
                        "allowedValues": [
                            {
                                "description": "",
                                "value": "USER"
                            },
                            {
                                "description": "",
                                "value": "SERVICE"
                            }
                        ]
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.security.providers.httpauth.HttpDigestAuthProvider.Builder",
                "description": "Http digest authentication security provider",
                "prefix": "http-digest-auth",
                "type": "io.helidon.security.providers.httpauth.HttpDigestAuthProvider",
                "producers": [
                    "io.helidon.security.providers.httpauth.HttpDigestAuthProvider.Builder#build()",
                    "io.helidon.security.providers.httpauth.HttpDigestAuthProvider#create(io.helidon.common.config.Config)"
                ],
                "provides": [
                    "io.helidon.security.spi.SecurityProvider",
                    "io.helidon.security.spi.AuthenticationProvider"
                ],
                "options": [
                    {
                        "defaultValue": "NONE",
                        "description": "Only `AUTH` supported. If left empty, uses the legacy approach (older RFC version). `AUTH-INT` is not supported.",
                        "key": "qop",
                        "method": "io.helidon.security.providers.httpauth.HttpDigestAuthProvider.Builder#addDigestQop(io.helidon.security.providers.httpauth.HttpDigest.Qop)",
                        "type": "io.helidon.security.providers.httpauth.HttpDigest.Qop",
                        "allowedValues": [
                            {
                                "description": "Legacy approach - used internally to parse headers. Do not use this option when\n building provider. If you want to support only legacy RFC, please use\n HttpDigestAuthProvider.Builder#noDigestQop().\n Only #AUTH is supported, as auth-int requires access to message body.",
                                "value": "NONE"
                            },
                            {
                                "description": "QOP \"auth\" - stands for \"authentication\".",
                                "value": "AUTH"
                            }
                        ]
                    },
                    {
                        "description": "Set user store to obtain passwords and roles based on logins.",
                        "key": "users",
                        "kind": "LIST",
                        "method": "io.helidon.security.providers.httpauth.HttpDigestAuthProvider.Builder#userStore(io.helidon.security.providers.httpauth.SecureUserStore)",
                        "type": "io.helidon.security.providers.httpauth.ConfigUserStore.ConfigUser"
                    },
                    {
                        "defaultValue": "86400000",
                        "description": "How long will the nonce value be valid. When timed-out, browser will re-request username/password.",
                        "key": "nonce-timeout-millis",
                        "method": "io.helidon.security.providers.httpauth.HttpDigestAuthProvider.Builder#digestNonceTimeout(long, java.util.concurrent.TimeUnit)",
                        "type": "java.lang.Long"
                    },
                    {
                        "description": "The nonce is encrypted using this secret - to make sure the nonce we get back was generated by us and to\n make sure we can safely time-out nonce values.\n This secret must be the same for all service instances (or all services that want to share the same authentication).\n Defaults to a random password - e.g. if deployed to multiple servers, the authentication WILL NOT WORK. You MUST\n provide your own password to work in a distributed environment with non-sticky load balancing.",
                        "key": "server-secret",
                        "method": "io.helidon.security.providers.httpauth.HttpDigestAuthProvider.Builder#digestServerSecret(char[])"
                    },
                    {
                        "defaultValue": "false",
                        "description": "Whether authentication is required.\n By default, request will fail if the authentication cannot be verified.\n If set to false, request will process and this provider will abstain.",
                        "key": "optional",
                        "method": "io.helidon.security.providers.httpauth.HttpDigestAuthProvider.Builder#optional(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "Helidon",
                        "description": "Set the realm to use when challenging users.",
                        "key": "realm",
                        "method": "io.helidon.security.providers.httpauth.HttpDigestAuthProvider.Builder#realm(java.lang.String)"
                    },
                    {
                        "defaultValue": "MD5",
                        "description": "Digest algorithm to use.",
                        "key": "algorithm",
                        "method": "io.helidon.security.providers.httpauth.HttpDigestAuthProvider.Builder#digestAlgorithm(io.helidon.security.providers.httpauth.HttpDigest.Algorithm)",
                        "type": "io.helidon.security.providers.httpauth.HttpDigest.Algorithm",
                        "allowedValues": [
                            {
                                "description": "MD5 algorithm.",
                                "value": "MD5"
                            }
                        ]
                    },
                    {
                        "defaultValue": "USER",
                        "description": "Principal type this provider extracts (and also propagates).",
                        "key": "principal-type",
                        "method": "io.helidon.security.providers.httpauth.HttpDigestAuthProvider.Builder#subjectType(io.helidon.security.SubjectType)",
                        "type": "io.helidon.security.SubjectType",
                        "allowedValues": [
                            {
                                "description": "",
                                "value": "USER"
                            },
                            {
                                "description": "",
                                "value": "SERVICE"
                            }
                        ]
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.security.providers.header",
        "types": [
            {
                "annotatedType": "io.helidon.security.providers.header.HeaderAtnProvider.Builder",
                "description": "Security provider that extracts a username (or service name) from a header.",
                "prefix": "header-atn",
                "type": "io.helidon.security.providers.header.HeaderAtnProvider",
                "producers": [
                    "io.helidon.security.providers.header.HeaderAtnProvider.Builder#build()",
                    "io.helidon.security.providers.header.HeaderAtnProvider#create(io.helidon.common.config.Config)"
                ],
                "provides": [
                    "io.helidon.security.spi.SecurityProvider",
                    "io.helidon.security.spi.AuthenticationProvider"
                ],
                "options": [
                    {
                        "defaultValue": "true",
                        "description": "Whether to authenticate requests.",
                        "key": "authenticate",
                        "method": "io.helidon.security.providers.header.HeaderAtnProvider.Builder#authenticate(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Token handler to extract username from request.",
                        "key": "atn-token",
                        "method": "io.helidon.security.providers.header.HeaderAtnProvider.Builder#atnTokenHandler(io.helidon.security.util.TokenHandler)",
                        "type": "io.helidon.security.util.TokenHandler"
                    },
                    {
                        "defaultValue": "false",
                        "description": "Whether authentication is required.\n By default, request will fail if the username cannot be extracted.\n If set to false, request will process and this provider will abstain.",
                        "key": "optional",
                        "method": "io.helidon.security.providers.header.HeaderAtnProvider.Builder#optional(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "false",
                        "description": "Whether to propagate identity.",
                        "key": "propagate",
                        "method": "io.helidon.security.providers.header.HeaderAtnProvider.Builder#propagate(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Configure outbound target for identity propagation.",
                        "key": "outbound",
                        "kind": "LIST",
                        "method": "io.helidon.security.providers.header.HeaderAtnProvider.Builder#addOutboundTarget(io.helidon.security.providers.common.OutboundTarget)",
                        "type": "io.helidon.security.providers.common.OutboundTarget"
                    },
                    {
                        "description": "Token handler to create outbound headers to propagate identity.\n If not defined, #atnTokenHandler will be used.",
                        "key": "outbound-token",
                        "method": "io.helidon.security.providers.header.HeaderAtnProvider.Builder#outboundTokenHandler(io.helidon.security.util.TokenHandler)",
                        "type": "io.helidon.security.util.TokenHandler"
                    },
                    {
                        "defaultValue": "USER",
                        "description": "Principal type this provider extracts (and also propagates).",
                        "key": "principal-type",
                        "method": "io.helidon.security.providers.header.HeaderAtnProvider.Builder#subjectType(io.helidon.security.SubjectType)",
                        "type": "io.helidon.security.SubjectType",
                        "allowedValues": [
                            {
                                "description": "",
                                "value": "USER"
                            },
                            {
                                "description": "",
                                "value": "SERVICE"
                            }
                        ]
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.openapi.ui",
        "types": [
            {
                "annotatedType": "io.helidon.openapi.ui.OpenApiUiConfig",
                "type": "io.helidon.openapi.ui.OpenApiUi",
                "producers": [
                    "io.helidon.openapi.ui.OpenApiUiConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.openapi.ui.OpenApiUiConfig#builder()",
                    "io.helidon.openapi.ui.OpenApiUi#create(io.helidon.openapi.ui.OpenApiUiConfig)"
                ],
                "options": [
                    {
                        "description": "Full web context (not just the suffix).\n\n @return full web context path",
                        "key": "web-context",
                        "method": "io.helidon.openapi.ui.OpenApiUiConfig.Builder#webContext(java.lang.String)"
                    },
                    {
                        "description": "Merges implementation-specific UI options.\n\n @return options for the UI to merge",
                        "key": "options",
                        "kind": "MAP",
                        "method": "io.helidon.openapi.ui.OpenApiUiConfig.Builder#options(java.lang.String)"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Sets whether the service should be enabled.\n\n @return `true` if enabled, `false` otherwise",
                        "key": "enabled",
                        "method": "io.helidon.openapi.ui.OpenApiUiConfig.Builder#isEnabled(java.lang.Boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.openapi",
        "types": [
            {
                "annotatedType": "io.helidon.openapi.OpenApiFeatureConfig",
                "prefix": "openapi",
                "type": "io.helidon.openapi.OpenApiFeature",
                "standalone": true,
                "producers": [
                    "io.helidon.openapi.OpenApiFeatureConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.openapi.OpenApiFeatureConfig#builder()",
                    "io.helidon.openapi.OpenApiFeature#create(io.helidon.openapi.OpenApiFeatureConfig)"
                ],
                "provides": [
                    "io.helidon.webserver.spi.ServerFeatureProvider"
                ],
                "options": [
                    {
                        "defaultValue": "/openapi",
                        "description": "Web context path for the OpenAPI endpoint.\n\n @return webContext to use",
                        "key": "web-context",
                        "method": "io.helidon.openapi.OpenApiFeatureConfig.Builder#webContext(java.lang.String)"
                    },
                    {
                        "description": "CORS config.\n\n @return CORS config",
                        "key": "cors",
                        "method": "io.helidon.openapi.OpenApiFeatureConfig.Builder#cors(java.util.Optional<io.helidon.cors.CrossOriginConfig>)",
                        "type": "io.helidon.cors.CrossOriginConfig"
                    },
                    {
                        "description": "List of sockets to register this feature on. If empty, it would get registered on all sockets.\n\n @return socket names to register on, defaults to empty (all available sockets)",
                        "key": "sockets",
                        "kind": "LIST",
                        "method": "io.helidon.openapi.OpenApiFeatureConfig.Builder#sockets(java.util.Set<java.lang.String>)"
                    },
                    {
                        "description": "OpenAPI manager.\n\n @return the OpenAPI manager",
                        "key": "manager",
                        "method": "io.helidon.openapi.OpenApiFeatureConfig.Builder#manager(java.util.Optional<io.helidon.openapi.OpenApiManager<?>>)",
                        "providerType": "io.helidon.openapi.spi.OpenApiManagerProvider",
                        "type": "io.helidon.openapi.OpenApiManager",
                        "provider": true
                    },
                    {
                        "defaultValue": "90.0",
                        "description": "Weight of the OpenAPI feature. This is quite low, to be registered after routing.\n {@value io.helidon.openapi.OpenApiFeature#WEIGHT}.\n\n @return weight of the feature",
                        "key": "weight",
                        "method": "io.helidon.openapi.OpenApiFeatureConfig.Builder#weight(double)",
                        "type": "java.lang.Double"
                    },
                    {
                        "defaultValue": "openapi",
                        "description": "Hints for role names the user is expected to be in.\n\n @return list of hints",
                        "key": "roles",
                        "kind": "LIST",
                        "method": "io.helidon.openapi.OpenApiFeatureConfig.Builder#roles(java.util.List<java.lang.String>)"
                    },
                    {
                        "description": "Path of the static OpenAPI document file. Default types are `json`, `yaml`, and `yml`.\n\n @return location of the static OpenAPI document file",
                        "key": "static-file",
                        "method": "io.helidon.openapi.OpenApiFeatureConfig.Builder#staticFile(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "description": "OpenAPI services.\n\n @return the OpenAPI services",
                        "key": "services",
                        "kind": "LIST",
                        "method": "io.helidon.openapi.OpenApiFeatureConfig.Builder#services(java.util.List<io.helidon.openapi.OpenApiService>)",
                        "providerType": "io.helidon.openapi.spi.OpenApiServiceProvider",
                        "type": "io.helidon.openapi.OpenApiService",
                        "provider": true
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether to allow anybody to access the endpoint.\n\n @return whether to permit access to metrics endpoint to anybody, defaults to `true`\n @see #roles()",
                        "key": "permit-all",
                        "method": "io.helidon.openapi.OpenApiFeatureConfig.Builder#permitAll(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Sets whether the feature should be enabled.\n\n @return `true` if enabled, `false` otherwise",
                        "key": "enabled",
                        "method": "io.helidon.openapi.OpenApiFeatureConfig.Builder#isEnabled(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.integrations.neo4j",
        "types": [
            {
                "annotatedType": "io.helidon.integrations.neo4j.Neo4j.Builder",
                "type": "io.helidon.integrations.neo4j.Neo4j",
                "producers": [
                    "io.helidon.integrations.neo4j.Neo4j.Builder#build()",
                    "io.helidon.integrations.neo4j.Neo4j#create(io.helidon.common.config.Config)"
                ],
                "options": [
                    {
                        "description": "Set trust strategy.",
                        "key": "trust-strategy",
                        "method": "io.helidon.integrations.neo4j.Neo4j.Builder#trustStrategy(io.helidon.integrations.neo4j.Neo4j.Builder.TrustStrategy)",
                        "type": "io.helidon.integrations.neo4j.Neo4j.Builder.TrustStrategy",
                        "allowedValues": [
                            {
                                "description": "Trust all.",
                                "value": "TRUST_ALL_CERTIFICATES"
                            },
                            {
                                "description": "Trust custom certificates.",
                                "value": "TRUST_CUSTOM_CA_SIGNED_CERTIFICATES"
                            },
                            {
                                "description": "Trust system CA.",
                                "value": "TRUST_SYSTEM_CA_SIGNED_CERTIFICATES"
                            }
                        ]
                    },
                    {
                        "defaultValue": "PT1MS",
                        "description": "Set idle time.",
                        "key": "idle-time-before-connection-test",
                        "method": "io.helidon.integrations.neo4j.Neo4j.Builder#idleTimeBeforeConnectionTest(java.time.Duration)",
                        "type": "java.time.Duration"
                    },
                    {
                        "description": "Set certificate path.",
                        "key": "certificate",
                        "method": "io.helidon.integrations.neo4j.Neo4j.Builder#certificate(java.nio.file.Path)",
                        "type": "java.nio.file.Path"
                    },
                    {
                        "description": "Create uri.",
                        "key": "uri",
                        "method": "io.helidon.integrations.neo4j.Neo4j.Builder#uri(java.lang.String)"
                    },
                    {
                        "description": "Enable metrics.",
                        "key": "metrics-enabled",
                        "method": "io.helidon.integrations.neo4j.Neo4j.Builder#metricsEnabled(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Enable hostname verification.",
                        "key": "hostname-verification-enabled",
                        "method": "io.helidon.integrations.neo4j.Neo4j.Builder#hostnameVerificationEnabled(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "PT1M",
                        "description": "Set connection acquisition timeout.",
                        "key": "connection-acquisition-timeout",
                        "method": "io.helidon.integrations.neo4j.Neo4j.Builder#connectionAcquisitionTimeout(java.time.Duration)",
                        "type": "java.time.Duration"
                    },
                    {
                        "defaultValue": "100",
                        "description": "Set pool size.",
                        "key": "max-connection-pool-size",
                        "method": "io.helidon.integrations.neo4j.Neo4j.Builder#maxConnectionPoolSize(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "description": "Create password.",
                        "key": "password",
                        "method": "io.helidon.integrations.neo4j.Neo4j.Builder#password(java.lang.String)"
                    },
                    {
                        "description": "Enable encrypted field.",
                        "key": "encrypted",
                        "method": "io.helidon.integrations.neo4j.Neo4j.Builder#encrypted(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Enable authentication.",
                        "key": "authentication-enabled",
                        "method": "io.helidon.integrations.neo4j.Neo4j.Builder#authenticationEnabled(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Enable log leaked sessions.",
                        "key": "log-leaked-sessions",
                        "method": "io.helidon.integrations.neo4j.Neo4j.Builder#logLeakedSessions(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Create username.",
                        "key": "username",
                        "method": "io.helidon.integrations.neo4j.Neo4j.Builder#username(java.lang.String)"
                    },
                    {
                        "defaultValue": "PT5H",
                        "description": "Set max life time.",
                        "key": "max-connection-lifetime",
                        "method": "io.helidon.integrations.neo4j.Neo4j.Builder#maxConnectionLifetime(java.time.Duration)",
                        "type": "java.time.Duration"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.integrations.openapi.ui",
        "types": [
            {
                "annotatedType": "io.helidon.integrations.openapi.ui.OpenApiUiConfig",
                "type": "io.helidon.integrations.openapi.ui.OpenApiUi",
                "producers": [
                    "io.helidon.integrations.openapi.ui.OpenApiUiConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.integrations.openapi.ui.OpenApiUiConfig#builder()",
                    "io.helidon.integrations.openapi.ui.OpenApiUi#create(io.helidon.integrations.openapi.ui.OpenApiUiConfig)"
                ],
                "options": [
                    {
                        "description": "Full web context (not just the suffix).\n\n @return full web context path",
                        "key": "web-context",
                        "method": "io.helidon.integrations.openapi.ui.OpenApiUiConfig.Builder#webContext(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "description": "Merges implementation-specific UI options.\n\n @return options for the UI to merge",
                        "key": "options",
                        "kind": "MAP",
                        "method": "io.helidon.integrations.openapi.ui.OpenApiUiConfig.Builder#options(java.util.Map<java.lang.String, java.lang.String>)"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Sets whether the service should be enabled.\n\n @return `true` if enabled, `false` otherwise",
                        "key": "enabled",
                        "method": "io.helidon.integrations.openapi.ui.OpenApiUiConfig.Builder#isEnabled(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.integrations.micrometer",
        "types": [
            {
                "annotatedType": "io.helidon.integrations.micrometer.MicrometerFeature.Builder",
                "prefix": "micrometer",
                "type": "io.helidon.integrations.micrometer.MicrometerFeature",
                "inherits": [
                    "io.helidon.webserver.servicecommon.HelidonFeatureSupport.Builder"
                ],
                "producers": [
                    "io.helidon.integrations.micrometer.MicrometerFeature.Builder#build()",
                    "io.helidon.integrations.micrometer.MicrometerFeature#create(io.helidon.common.config.Config)"
                ],
                "options": []
            }
        ]
    }
]
[
    {
        "module": "io.helidon.integrations.oci.metrics",
        "types": [
            {
                "annotatedType": "io.helidon.integrations.oci.metrics.OciMetricsSupport.Builder",
                "type": "io.helidon.integrations.oci.metrics.OciMetricsSupport",
                "producers": [
                    "io.helidon.integrations.oci.metrics.OciMetricsSupport.Builder#build()"
                ],
                "options": [
                    {
                        "defaultValue": "60",
                        "description": "Sets the delay interval between metric posting\n (defaults to {@value #DEFAULT_SCHEDULER_DELAY}).",
                        "key": "delay",
                        "method": "io.helidon.integrations.oci.metrics.OciMetricsSupport.Builder#delay(long)",
                        "type": "java.lang.Long"
                    },
                    {
                        "description": "Sets the resource group.",
                        "key": "resource-group",
                        "method": "io.helidon.integrations.oci.metrics.OciMetricsSupport.Builder#resourceGroup(java.lang.String)"
                    },
                    {
                        "description": "Sets the compartment ID.",
                        "key": "compartment-id",
                        "method": "io.helidon.integrations.oci.metrics.OciMetricsSupport.Builder#compartmentId(java.lang.String)"
                    },
                    {
                        "defaultValue": "1",
                        "description": "Sets the delay interval if metrics are posted in batches\n (defaults to {@value #DEFAULT_BATCH_DELAY}).",
                        "key": "batch-delay",
                        "method": "io.helidon.integrations.oci.metrics.OciMetricsSupport.Builder#batchDelay(long)",
                        "type": "java.lang.Long"
                    },
                    {
                        "defaultValue": "50",
                        "description": "Sets the maximum no. of metrics to send in a batch\n (defaults to {@value #DEFAULT_BATCH_SIZE}).",
                        "key": "batch-size",
                        "method": "io.helidon.integrations.oci.metrics.OciMetricsSupport.Builder#batchSize(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "description": "Sets the namespace.",
                        "key": "namespace",
                        "method": "io.helidon.integrations.oci.metrics.OciMetricsSupport.Builder#namespace(java.lang.String)"
                    },
                    {
                        "defaultValue": "All scopes",
                        "description": "Sets which metrics scopes (e.g., base, vendor, application) should be sent to OCI.\n <p>\n     If this method is never invoked, defaults to all scopes.\n </p>",
                        "key": "scopes",
                        "method": "io.helidon.integrations.oci.metrics.OciMetricsSupport.Builder#scopes(java.lang.String[])",
                        "type": "java.lang.String[]"
                    },
                    {
                        "defaultValue": "TimeUnit.SECONDS",
                        "description": "Sets the time unit applied to the initial delay and delay values (defaults to `TimeUnit.SECONDS`).",
                        "key": "scheduling-time-unit",
                        "method": "io.helidon.integrations.oci.metrics.OciMetricsSupport.Builder#schedulingTimeUnit(java.util.concurrent.TimeUnit)",
                        "type": "java.util.concurrent.TimeUnit",
                        "allowedValues": [
                            {
                                "description": "",
                                "value": "NANOSECONDS"
                            },
                            {
                                "description": "",
                                "value": "MICROSECONDS"
                            },
                            {
                                "description": "",
                                "value": "MILLISECONDS"
                            },
                            {
                                "description": "",
                                "value": "SECONDS"
                            },
                            {
                                "description": "",
                                "value": "MINUTES"
                            },
                            {
                                "description": "",
                                "value": "HOURS"
                            },
                            {
                                "description": "",
                                "value": "DAYS"
                            }
                        ]
                    },
                    {
                        "defaultValue": "true",
                        "description": "Sets whether the description should be enabled or not.\n <p>\n     Defaults to `true`.\n </p>",
                        "key": "description-enabled",
                        "method": "io.helidon.integrations.oci.metrics.OciMetricsSupport.Builder#descriptionEnabled(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "1",
                        "description": "Sets the initial delay before metrics are sent to OCI\n (defaults to {@value #DEFAULT_SCHEDULER_INITIAL_DELAY}).",
                        "key": "initial-delay",
                        "method": "io.helidon.integrations.oci.metrics.OciMetricsSupport.Builder#initialDelay(long)",
                        "type": "java.lang.Long"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Sets whether metrics transmission to OCI is enabled.\n <p>\n     Defaults to `true`.\n </p>",
                        "key": "enabled",
                        "method": "io.helidon.integrations.oci.metrics.OciMetricsSupport.Builder#enabled(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.integrations.oci.sdk.runtime",
        "types": [
            {
                "annotatedType": "io.helidon.integrations.oci.sdk.runtime.OciConfig",
                "prefix": "oci",
                "type": "io.helidon.integrations.oci.sdk.runtime.OciConfig",
                "standalone": true,
                "producers": [
                    "io.helidon.integrations.oci.sdk.runtime.OciConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.integrations.oci.sdk.runtime.OciConfig#builder()"
                ],
                "options": [
                    {
                        "description": "The OCI region.\n <p>\n This configuration property has an effect only when `config` is, explicitly or implicitly,\n present in the value for the #authStrategies(). This is also known as #simpleConfigIsPresent().\n When it is present, either this property or com.oracle.bmc.auth.RegionProvider must be provide a value in order\n to set the {@linkplain com.oracle.bmc.auth.ConfigFileAuthenticationDetailsProvider#getRegion()}.\n\n @return the OCI region",
                        "key": "auth.region",
                        "method": "io.helidon.integrations.oci.sdk.runtime.OciConfig.Builder#authRegion(java.lang.String)"
                    },
                    {
                        "description": "The OCI tenant id.\n <p>\n This configuration property has an effect only when `config` is, explicitly or implicitly,\n present in the value for the #authStrategies(). This is also known as #simpleConfigIsPresent().\n When it is present, this property must be provided in order to set the\n {@linkplain com.oracle.bmc.auth.ConfigFileAuthenticationDetailsProvider#getTenantId()}.\n\n @return the OCI tenant id",
                        "key": "auth.tenant-id",
                        "method": "io.helidon.integrations.oci.sdk.runtime.OciConfig.Builder#authTenantId(java.lang.String)"
                    },
                    {
                        "description": "The OCI configuration profile path.\n <p>\n This configuration property has an effect only when `config-file` is, explicitly or implicitly,\n present in the value for the #authStrategies(). This is also known as #fileConfigIsPresent().\n When it is present, this property must also be present and then the\n {@linkplain com.oracle.bmc.ConfigFileReader#parse(String)}\n method will be passed this value. It is expected to be passed with a\n valid OCI configuration file path.\n\n @return the OCI configuration profile path",
                        "key": "config.path",
                        "method": "io.helidon.integrations.oci.sdk.runtime.OciConfig.Builder#configPath(java.lang.String)"
                    },
                    {
                        "description": "The list of authentication strategies that will be attempted by\n com.oracle.bmc.auth.AbstractAuthenticationDetailsProvider when one is\n called for. This is only used if #authStrategy() is not present.\n\n <ul>\n      <li>`auto` - if present in the list, or if no value\n          for this property exists.</li>\n      <li>`config` - the\n          com.oracle.bmc.auth.SimpleAuthenticationDetailsProvider\n          will be used, customized with other configuration\n          properties described here.</li>\n      <li>`config-file` - the\n          com.oracle.bmc.auth.ConfigFileAuthenticationDetailsProvider\n          will be used, customized with other configuration\n          properties described here.</li>\n      <li>`instance-principals` - the\n          com.oracle.bmc.auth.InstancePrincipalsAuthenticationDetailsProvider\n          will be used.</li>\n      <li>`resource-principal` - the\n          com.oracle.bmc.auth.ResourcePrincipalAuthenticationDetailsProvider\n          will be used.</li>\n </ul>\n <p>\n If there are more than one strategy descriptors defined, the\n first one that is deemed to be available/suitable will be used and all others will be ignored.\n\n @return the list of authentication strategies that will be applied, defaulting to `auto`\n @see io.helidon.integrations.oci.sdk.runtime.OciAuthenticationDetailsProvider.AuthStrategy",
                        "key": "auth-strategies",
                        "kind": "LIST",
                        "method": "io.helidon.integrations.oci.sdk.runtime.OciConfig.Builder#authStrategies(java.lang.String)",
                        "allowedValues": [
                            {
                                "description": "auto select first applicable",
                                "value": "auto"
                            },
                            {
                                "description": "simple authentication provider",
                                "value": "config"
                            },
                            {
                                "description": "config file authentication provider",
                                "value": "config-file"
                            },
                            {
                                "description": "instance principals authentication provider",
                                "value": "instance-principals"
                            },
                            {
                                "description": "resource principal authentication provider",
                                "value": "resource-principal"
                            }
                        ]
                    },
                    {
                        "defaultValue": "DEFAULT",
                        "description": "The OCI configuration/auth profile name.\n <p>\n This configuration property has an effect only when `config-file` is, explicitly or implicitly,\n present in the value for the #authStrategies(). This is also known as #fileConfigIsPresent().\n When it is present, this property may also be optionally provided in order to override the default\n {@value #DEFAULT_PROFILE_NAME}.\n\n @return the optional OCI configuration/auth profile name",
                        "key": "config.profile",
                        "method": "io.helidon.integrations.oci.sdk.runtime.OciConfig.Builder#configProfile(java.lang.String)"
                    },
                    {
                        "defaultValue": "oci_api_key.pem",
                        "description": "The OCI authentication key file.\n <p>\n This configuration property has an effect only when `config` is, explicitly or implicitly,\n present in the value for the #authStrategies(). This is also known as #simpleConfigIsPresent().\n When it is present, this property must be provided in order to set the\n {@linkplain com.oracle.bmc.auth.SimpleAuthenticationDetailsProvider#getPrivateKey()}. This file must exist in the\n `user.home` directory. Alternatively, this property can be set using either #authPrivateKey() or\n using #authPrivateKeyPath().\n\n @return the OCI authentication key file",
                        "key": "auth.keyFile",
                        "method": "io.helidon.integrations.oci.sdk.runtime.OciConfig.Builder#authKeyFile(java.lang.String)"
                    },
                    {
                        "description": "The OCI authentication private key.\n <p>\n This configuration property has an effect only when `config` is, explicitly or implicitly,\n present in the value for the #authStrategies(). This is also known as #simpleConfigIsPresent().\n When it is present, this property must be provided in order to set the\n {@linkplain com.oracle.bmc.auth.SimpleAuthenticationDetailsProvider#getPrivateKey()}. Alternatively, this property\n can be set using either #authKeyFile() residing in the `user.home` directory, or using\n #authPrivateKeyPath().\n\n @return the OCI authentication private key",
                        "key": "auth.private-key",
                        "method": "io.helidon.integrations.oci.sdk.runtime.OciConfig.Builder#authPrivateKey(char[])",
                        "type": "char[]"
                    },
                    {
                        "description": "The OCI user id.\n <p>\n This configuration property has an effect only when `config` is, explicitly or implicitly,\n present in the value for the #authStrategies().\n When it is present, this property must be provided in order to set the\n {@linkplain com.oracle.bmc.auth.ConfigFileAuthenticationDetailsProvider#getUserId()}.\n\n @return the OCI user id",
                        "key": "auth.user-id",
                        "method": "io.helidon.integrations.oci.sdk.runtime.OciConfig.Builder#authUserId(java.lang.String)"
                    },
                    {
                        "defaultValue": "169.254.169.254",
                        "description": "The OCI IMDS hostname.\n <p>\n This configuration property is used to identify the metadata service url.\n\n @return the OCI IMDS hostname",
                        "key": "imds.hostname",
                        "method": "io.helidon.integrations.oci.sdk.runtime.OciConfig.Builder#imdsHostName(java.lang.String)"
                    },
                    {
                        "description": "The OCI authentication fingerprint.\n <p>\n This configuration property has an effect only when `config` is, explicitly or implicitly,\n present in the value for the #authStrategies(). This is also known as #simpleConfigIsPresent().\n When it is present, this property must be provided in order to set the <a\n href=\"https://docs.oracle.com/en-us/iaas/Content/API/Concepts/apisigningkey.htm\">API signing key's fingerprint</a>.\n See {@linkplain com.oracle.bmc.auth.SimpleAuthenticationDetailsProvider#getFingerprint()} for more details.\n\n @return the OCI authentication fingerprint",
                        "key": "auth.fingerprint",
                        "method": "io.helidon.integrations.oci.sdk.runtime.OciConfig.Builder#authFingerprint(java.lang.String)"
                    },
                    {
                        "description": "The singular authentication strategy to apply. This will be preferred over #authStrategies() if both are\n present.\n\n @return the singular authentication strategy to be applied",
                        "key": "auth-strategy",
                        "method": "io.helidon.integrations.oci.sdk.runtime.OciConfig.Builder#authStrategy(java.lang.String)",
                        "allowedValues": [
                            {
                                "description": "auto select first applicable",
                                "value": "auto"
                            },
                            {
                                "description": "simple authentication provider",
                                "value": "config"
                            },
                            {
                                "description": "config file authentication provider",
                                "value": "config-file"
                            },
                            {
                                "description": "instance principals authentication provider",
                                "value": "instance-principals"
                            },
                            {
                                "description": "resource principals authentication provider",
                                "value": "resource-principal"
                            }
                        ]
                    },
                    {
                        "description": "The OCI authentication key file path.\n <p>\n This configuration property has an effect only when `config` is, explicitly or implicitly,\n present in the value for the #authStrategies(). This is also known as #simpleConfigIsPresent().\n When it is present, this property must be provided in order to set the\n {@linkplain com.oracle.bmc.auth.SimpleAuthenticationDetailsProvider#getPrivateKey()}. This file path is\n an alternative for using #authKeyFile() where the file must exist in the `user.home` directory.\n Alternatively, this property can be set using #authPrivateKey().\n\n @return the OCI authentication key file path",
                        "key": "auth.private-key-path",
                        "method": "io.helidon.integrations.oci.sdk.runtime.OciConfig.Builder#authPrivateKeyPath(java.lang.String)"
                    },
                    {
                        "description": "The OCI authentication passphrase.\n <p>\n This configuration property has an effect only when `config` is, explicitly or implicitly,\n present in the value for the #authStrategies(). This is also known as #simpleConfigIsPresent().\n When it is present, this property must be provided in order to set the\n {@linkplain com.oracle.bmc.auth.SimpleAuthenticationDetailsProvider#getPassphraseCharacters()}.\n\n @return the OCI authentication passphrase",
                        "key": "auth.passphrase",
                        "method": "io.helidon.integrations.oci.sdk.runtime.OciConfig.Builder#authPassphrase(char[])",
                        "type": "char[]"
                    },
                    {
                        "defaultValue": "PT0.1S",
                        "description": "The OCI IMDS connection timeout. This is used to auto-detect availability.\n <p>\n This configuration property is used when attempting to connect to the metadata service.\n\n @return the OCI IMDS connection timeout\n @see OciAvailability",
                        "key": "imds.timeout.milliseconds",
                        "method": "io.helidon.integrations.oci.sdk.runtime.OciConfig.Builder#imdsTimeout(java.time.Duration)",
                        "type": "java.time.Duration"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.webserver.websocket",
        "types": [
            {
                "annotatedType": "io.helidon.webserver.websocket.WsConfig",
                "type": "io.helidon.webserver.websocket.WsConfig",
                "producers": [
                    "io.helidon.webserver.websocket.WsConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.webserver.websocket.WsConfig#builder()"
                ],
                "provides": [
                    "io.helidon.webserver.spi.ProtocolConfig"
                ],
                "options": [
                    {
                        "description": "WebSocket origins.\n\n @return origins",
                        "key": "origins",
                        "kind": "LIST",
                        "method": "io.helidon.webserver.websocket.WsConfig.Builder#origins(java.util.Set<java.lang.String>)"
                    },
                    {
                        "defaultValue": "websocket",
                        "description": "Name of this configuration.\n\n @return configuration name",
                        "key": "name",
                        "method": "io.helidon.webserver.websocket.WsConfig.Builder#name(java.lang.String)"
                    },
                    {
                        "defaultValue": "1048576",
                        "description": "Max WebSocket frame size supported by the server on a read operation.\n Default is 1 MB.\n\n @return max frame size to read",
                        "key": "max-frame-length",
                        "method": "io.helidon.webserver.websocket.WsConfig.Builder#maxFrameLength(int)",
                        "type": "java.lang.Integer"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.webserver.context",
        "types": [
            {
                "annotatedType": "io.helidon.webserver.context.ContextFeatureConfig",
                "prefix": "context",
                "type": "io.helidon.webserver.context.ContextFeature",
                "producers": [
                    "io.helidon.webserver.context.ContextFeatureConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.webserver.context.ContextFeatureConfig#builder()",
                    "io.helidon.webserver.context.ContextFeature#create(io.helidon.webserver.context.ContextFeatureConfig)"
                ],
                "provides": [
                    "io.helidon.webserver.spi.ServerFeatureProvider"
                ],
                "options": [
                    {
                        "description": "List of sockets to register this feature on. If empty, it would get registered on all sockets.\n\n @return socket names to register on, defaults to empty (all available sockets)",
                        "key": "sockets",
                        "kind": "LIST",
                        "method": "io.helidon.webserver.context.ContextFeatureConfig.Builder#sockets(java.util.Set<java.lang.String>)"
                    },
                    {
                        "defaultValue": "1100.0",
                        "description": "Weight of the context feature. As it is used by other features, the default is quite high:\n {@value io.helidon.webserver.context.ContextFeature#WEIGHT}.\n\n @return weight of the feature",
                        "key": "weight",
                        "method": "io.helidon.webserver.context.ContextFeatureConfig.Builder#weight(double)",
                        "type": "java.lang.Double"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.webserver.accesslog",
        "types": [
            {
                "annotatedType": "io.helidon.webserver.accesslog.AccessLogConfig",
                "prefix": "access-log",
                "type": "io.helidon.webserver.accesslog.AccessLogFeature",
                "producers": [
                    "io.helidon.webserver.accesslog.AccessLogConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.webserver.accesslog.AccessLogConfig#builder()",
                    "io.helidon.webserver.accesslog.AccessLogFeature#create(io.helidon.webserver.accesslog.AccessLogConfig)"
                ],
                "provides": [
                    "io.helidon.webserver.spi.ServerFeatureProvider"
                ],
                "options": [
                    {
                        "description": "List of sockets to register this feature on. If empty, it would get registered on all sockets.\n The logger used will have the expected logger with a suffix of the socket name.\n\n @return socket names to register on, defaults to empty (all available sockets)",
                        "key": "sockets",
                        "kind": "LIST",
                        "method": "io.helidon.webserver.accesslog.AccessLogConfig.Builder#sockets(java.util.Set<java.lang.String>)"
                    },
                    {
                        "defaultValue": "1000.0",
                        "description": "Weight of the access log feature. We need to log access for anything happening on the server, so weight is high:\n {@value io.helidon.webserver.accesslog.AccessLogFeature#WEIGHT}.\n\n @return weight of the feature",
                        "key": "weight",
                        "method": "io.helidon.webserver.accesslog.AccessLogConfig.Builder#weight(double)",
                        "type": "java.lang.Double"
                    },
                    {
                        "defaultValue": "io.helidon.webserver.AccessLog",
                        "description": "Name of the logger used to obtain access log logger from System#getLogger(String).\n Defaults to {@value AccessLogFeature#DEFAULT_LOGGER_NAME}.\n\n @return name of the logger to use",
                        "key": "logger-name",
                        "method": "io.helidon.webserver.accesslog.AccessLogConfig.Builder#loggerName(java.lang.String)"
                    },
                    {
                        "description": "The format for log entries (similar to the Apache `LogFormat`).\n <table class=\"config\">\n     <caption>Log format elements</caption>\n     <tr>\n         <td>%h</td>\n         <td>IP address of the remote host</td>\n         <td>HostLogEntry</td>\n     </tr>\n     <tr>\n         <td>%l</td>\n         <td>The client identity. This is always undefined in Helidon.</td>\n         <td>UserIdLogEntry</td>\n     </tr>\n     <tr>\n         <td>%u</td>\n         <td>User ID as asserted by Helidon Security.</td>\n         <td>UserLogEntry</td>\n     </tr>\n     <tr>\n         <td>%t</td>\n         <td>The timestamp</td>\n         <td>TimestampLogEntry</td>\n     </tr>\n     <tr>\n         <td>%r</td>\n         <td>The request line (`\"GET /favicon.ico HTTP/1.0\"`)</td>\n         <td>RequestLineLogEntry</td>\n     </tr>\n     <tr>\n         <td>%s</td>\n         <td>The status code returned to the client</td>\n         <td>StatusLogEntry</td>\n     </tr>\n     <tr>\n         <td>%b</td>\n         <td>The entity size in bytes</td>\n         <td>SizeLogEntry</td>\n     </tr>\n     <tr>\n         <td>%D</td>\n         <td>The time taken in microseconds (start of request until last byte written)</td>\n         <td>TimeTakenLogEntry</td>\n     </tr>\n     <tr>\n         <td>%T</td>\n         <td>The time taken in seconds (start of request until last byte written), integer</td>\n         <td>TimeTakenLogEntry</td>\n     </tr>\n     <tr>\n         <td>%{header-name}i</td>\n         <td>Value of header `header-name`</td>\n         <td>HeaderLogEntry</td>\n     </tr>\n </table>\n\n @return format string, such as `%h %l %u %t %r %b %{Referer`i}",
                        "key": "format",
                        "method": "io.helidon.webserver.accesslog.AccessLogConfig.Builder#format(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether this feature will be enabled.\n\n @return whether enabled",
                        "key": "enabled",
                        "method": "io.helidon.webserver.accesslog.AccessLogConfig.Builder#enabled(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.webserver.grpc",
        "types": [
            {
                "annotatedType": "io.helidon.webserver.grpc.GrpcConfig",
                "type": "io.helidon.webserver.grpc.GrpcConfig",
                "producers": [
                    "io.helidon.webserver.grpc.GrpcConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.webserver.grpc.GrpcConfig#builder()"
                ],
                "provides": [
                    "io.helidon.webserver.spi.ProtocolConfig"
                ],
                "options": []
            }
        ]
    }
]
[
    {
        "module": "io.helidon.webserver.security",
        "types": [
            {
                "annotatedType": "io.helidon.webserver.security.SecurityHandlerConfig",
                "type": "io.helidon.webserver.security.SecurityHandler",
                "producers": [
                    "io.helidon.webserver.security.SecurityHandlerConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.webserver.security.SecurityHandlerConfig#builder()",
                    "io.helidon.webserver.security.SecurityHandler#create(io.helidon.webserver.security.SecurityHandlerConfig)"
                ],
                "options": [
                    {
                        "description": "If called, authentication failure will not abort request and will continue as anonymous (defaults to false).\n\n @return whether authn is optional",
                        "key": "authentication-optional",
                        "method": "io.helidon.webserver.security.SecurityHandlerConfig.Builder#authenticationOptional(java.util.Optional<java.lang.Boolean>)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "An array of allowed roles for this path - must have a security provider supporting roles (either authentication\n or authorization provider).\n This method enables authentication and authorization (you can disable them again by calling\n SecurityHandler#skipAuthorization()\n and #authenticationOptional() if needed).\n\n @return if subject is any of these roles, allow access",
                        "key": "roles-allowed",
                        "kind": "LIST",
                        "method": "io.helidon.webserver.security.SecurityHandlerConfig.Builder#rolesAllowed(java.util.Set<java.lang.String>)"
                    },
                    {
                        "description": "If called, request will go through authentication process - defaults to false (even if authorize is true).\n\n @return whether to authenticate or not",
                        "key": "authenticate",
                        "method": "io.helidon.webserver.security.SecurityHandlerConfig.Builder#authenticate(java.util.Optional<java.lang.Boolean>)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Use a named authorizer (as supported by security - if not defined, default authorizer is used, if none defined, all is\n permitted).\n Will enable authorization.\n\n @return name of authorizer as configured in io.helidon.security.Security",
                        "key": "authorizer",
                        "method": "io.helidon.webserver.security.SecurityHandlerConfig.Builder#authorizer(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "description": "List of sockets this configuration should be applied to.\n If empty, the configuration is applied to all configured sockets.\n\n @return list of sockets",
                        "key": "sockets",
                        "kind": "LIST",
                        "method": "io.helidon.webserver.security.SecurityHandlerConfig.Builder#sockets(java.util.List<java.lang.String>)"
                    },
                    {
                        "description": "Override for event-type, defaults to {@value SecurityHandler#DEFAULT_AUDIT_EVENT_TYPE}.\n\n @return audit event type to use",
                        "key": "audit-event-type",
                        "method": "io.helidon.webserver.security.SecurityHandlerConfig.Builder#auditEventType(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "description": "Whether to audit this request - defaults to false, if enabled, request is audited with event type \"request\".\n\n @return whether to audit",
                        "key": "audit",
                        "method": "io.helidon.webserver.security.SecurityHandlerConfig.Builder#audit(java.util.Optional<java.lang.Boolean>)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Override for audit message format, defaults to {@value SecurityHandler#DEFAULT_AUDIT_MESSAGE_FORMAT}.\n\n @return audit message format to use",
                        "key": "audit-message-format",
                        "method": "io.helidon.webserver.security.SecurityHandlerConfig.Builder#auditMessageFormat(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "description": "Use a named authenticator (as supported by security - if not defined, default authenticator is used).\n Will enable authentication.\n\n @return name of authenticator as configured in io.helidon.security.Security",
                        "key": "authenticator",
                        "method": "io.helidon.webserver.security.SecurityHandlerConfig.Builder#authenticator(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "description": "Enable authorization for this route.\n\n @return whether to authorize",
                        "key": "authorize",
                        "method": "io.helidon.webserver.security.SecurityHandlerConfig.Builder#authorize(java.util.Optional<java.lang.Boolean>)",
                        "type": "java.lang.Boolean"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.webserver.security.PathsConfig",
                "type": "io.helidon.webserver.security.PathsConfig",
                "producers": [
                    "io.helidon.webserver.security.PathsConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.webserver.security.PathsConfig#builder()"
                ],
                "options": [
                    {
                        "description": "",
                        "key": "path",
                        "method": "io.helidon.webserver.security.PathsConfig.Builder#path(java.lang.String)"
                    },
                    {
                        "description": "",
                        "key": "handler",
                        "method": "io.helidon.webserver.security.PathsConfig.Builder#handler(io.helidon.webserver.security.SecurityHandler)",
                        "type": "io.helidon.webserver.security.SecurityHandler",
                        "merge": true
                    },
                    {
                        "defaultValue": "@default",
                        "description": "",
                        "key": "sockets",
                        "kind": "LIST",
                        "method": "io.helidon.webserver.security.PathsConfig.Builder#sockets(java.util.List<java.lang.String>)"
                    },
                    {
                        "description": "",
                        "key": "methods",
                        "kind": "LIST",
                        "method": "io.helidon.webserver.security.PathsConfig.Builder#methods(java.util.List<io.helidon.http.Method>)",
                        "type": "io.helidon.http.Method"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.webserver.security.SecurityFeatureConfig",
                "prefix": "security",
                "type": "io.helidon.webserver.security.SecurityFeature",
                "producers": [
                    "io.helidon.webserver.security.SecurityFeatureConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.webserver.security.SecurityFeatureConfig#builder()",
                    "io.helidon.webserver.security.SecurityFeature#create(io.helidon.webserver.security.SecurityFeatureConfig)"
                ],
                "provides": [
                    "io.helidon.webserver.spi.ServerFeatureProvider"
                ],
                "options": [
                    {
                        "description": "Configuration for webserver paths.\n\n @return path configuration",
                        "key": "paths",
                        "kind": "LIST",
                        "method": "io.helidon.webserver.security.SecurityFeatureConfig.Builder#paths(java.util.List<io.helidon.webserver.security.PathsConfig>)",
                        "type": "io.helidon.webserver.security.PathsConfig"
                    },
                    {
                        "defaultValue": "800.0",
                        "description": "Weight of the security feature. Value is:\n {@value io.helidon.webserver.security.SecurityFeature#WEIGHT}.\n\n @return weight of the feature",
                        "key": "weight",
                        "method": "io.helidon.webserver.security.SecurityFeatureConfig.Builder#weight(double)",
                        "type": "java.lang.Double"
                    },
                    {
                        "defaultValue": "SecurityHandler.create()",
                        "description": "The default security handler.\n\n @return security handler defaults",
                        "key": "defaults",
                        "method": "io.helidon.webserver.security.SecurityFeatureConfig.Builder#defaults(io.helidon.webserver.security.SecurityHandler)",
                        "type": "io.helidon.webserver.security.SecurityHandler"
                    },
                    {
                        "description": "Security associated with this feature.\n If not specified here, the feature uses security registered with\n io.helidon.common.context.Contexts#globalContext(), if not found, it creates a new\n instance from root of configuration (using `security` key).\n <p>\n This configuration allows usage of a different security instance for a specific security feature setup.\n\n @return security instance to be used to handle security in this feature configuration",
                        "key": "security",
                        "method": "io.helidon.webserver.security.SecurityFeatureConfig.Builder#security(io.helidon.security.Security)",
                        "type": "io.helidon.security.Security"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.webserver.observe.metrics",
        "types": [
            {
                "annotatedType": "io.helidon.webserver.observe.metrics.MetricsObserverConfig",
                "prefix": "metrics",
                "type": "io.helidon.webserver.observe.metrics.MetricsObserver",
                "standalone": true,
                "producers": [
                    "io.helidon.webserver.observe.metrics.MetricsObserverConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.webserver.observe.metrics.MetricsObserverConfig#builder()",
                    "io.helidon.webserver.observe.metrics.MetricsObserver#create(io.helidon.webserver.observe.metrics.MetricsObserverConfig)"
                ],
                "provides": [
                    "io.helidon.webserver.observe.spi.ObserveProvider"
                ],
                "options": [
                    {
                        "defaultValue": "metrics",
                        "description": "",
                        "key": "endpoint",
                        "method": "io.helidon.webserver.observe.metrics.MetricsObserverConfig.Builder#endpoint(java.lang.String)"
                    },
                    {
                        "defaultValue": "@io.helidon.metrics.api.MetricsConfig@.create()",
                        "description": "Assigns `MetricsSettings` which will be used in creating the `MetricsSupport` instance at build-time.\n\n @return the metrics settings to assign for use in building the `MetricsSupport` instance",
                        "key": "metrics-config",
                        "method": "io.helidon.webserver.observe.metrics.MetricsObserverConfig.Builder#metricsConfig(io.helidon.metrics.api.MetricsConfig)",
                        "type": "io.helidon.metrics.api.MetricsConfig",
                        "merge": true
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.webserver.observe.tracing",
        "types": [
            {
                "annotatedType": "io.helidon.webserver.observe.tracing.TracingObserverConfig",
                "type": "io.helidon.webserver.observe.tracing.TracingObserver",
                "producers": [
                    "io.helidon.webserver.observe.tracing.TracingObserverConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.webserver.observe.tracing.TracingObserverConfig#builder()",
                    "io.helidon.webserver.observe.tracing.TracingObserver#create(io.helidon.webserver.observe.tracing.TracingObserverConfig)"
                ],
                "provides": [
                    "io.helidon.webserver.observe.spi.ObserveProvider"
                ],
                "options": [
                    {
                        "defaultValue": "TracingConfig.ENABLED",
                        "description": "Use the provided configuration as a default for any request.\n\n @return default web server tracing configuration",
                        "key": "env-config",
                        "method": "io.helidon.webserver.observe.tracing.TracingObserverConfig.Builder#envConfig(io.helidon.tracing.config.TracingConfig)",
                        "type": "io.helidon.tracing.config.TracingConfig",
                        "merge": true
                    },
                    {
                        "defaultValue": "new @java.util.ArrayList@(@java.util.List@.of(PathTracingConfig.builder()\n                                  .path(\"/metrics/*\")\n                                  .tracingConfig(TracingConfig.DISABLED)\n                                  .build(), \n                                  PathTracingConfig.builder()\n                                  .path(\"/observe/metrics/*\")\n                                  .tracingConfig(TracingConfig.DISABLED)\n                                  .build(), \n                                  PathTracingConfig.builder()\n                                  .path(\"/health/*\")\n                                  .tracingConfig(TracingConfig.DISABLED)\n                                  .build(), \n                                  PathTracingConfig.builder()\n                                  .path(\"/observe/health/*\")\n                                  .tracingConfig(TracingConfig.DISABLED)\n                                  .build(), \n                                  PathTracingConfig.builder()\n                                  .path(\"/openapi/*\")\n                                  .tracingConfig(TracingConfig.DISABLED)\n                                  .build(), \n                                  PathTracingConfig.builder()\n                                  .path(\"/observe/openapi/*\")\n                                  .tracingConfig(TracingConfig.DISABLED)\n                                  .build()))",
                        "description": "Path specific configuration of tracing.\n\n @return configuration of tracing for specific paths",
                        "key": "paths",
                        "kind": "LIST",
                        "method": "io.helidon.webserver.observe.tracing.TracingObserverConfig.Builder#pathConfigs(java.util.List<io.helidon.webserver.observe.tracing.PathTracingConfig>)",
                        "type": "io.helidon.webserver.observe.tracing.PathTracingConfig"
                    },
                    {
                        "defaultValue": "900.0",
                        "description": "Weight of the feature registered with WebServer.\n Changing weight may cause tracing to be executed at a different time (such as after security, or even after\n all routes). Please understand feature weights before changing this order.\n\n @return weight of tracing feature",
                        "key": "weight",
                        "method": "io.helidon.webserver.observe.tracing.TracingObserverConfig.Builder#weight(double)",
                        "type": "java.lang.Double"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.webserver.observe.config",
        "types": [
            {
                "annotatedType": "io.helidon.webserver.observe.config.ConfigObserverConfig",
                "type": "io.helidon.webserver.observe.config.ConfigObserver",
                "producers": [
                    "io.helidon.webserver.observe.config.ConfigObserverConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.webserver.observe.config.ConfigObserverConfig#builder()",
                    "io.helidon.webserver.observe.config.ConfigObserver#create(io.helidon.webserver.observe.config.ConfigObserverConfig)"
                ],
                "provides": [
                    "io.helidon.webserver.observe.spi.ObserveProvider"
                ],
                "options": [
                    {
                        "defaultValue": "config",
                        "description": "",
                        "key": "endpoint",
                        "method": "io.helidon.webserver.observe.config.ConfigObserverConfig.Builder#endpoint(java.lang.String)"
                    },
                    {
                        "defaultValue": ".*password, .*passphrase, .*secret",
                        "description": "Secret patterns (regular expressions) to exclude from output.\n Any pattern that matches a key will cause the output to be obfuscated and not contain the value.\n <p>\n Patterns always added:\n <ul>\n     <li>`.*password`</li>\n     <li>`.*passphrase`</li>\n     <li>`.*secret`</li>\n </ul>\n\n @return set of regular expression patterns for keys, where values should be excluded from output",
                        "key": "secrets",
                        "kind": "LIST",
                        "method": "io.helidon.webserver.observe.config.ConfigObserverConfig.Builder#secrets(java.util.Set<java.lang.String>)"
                    },
                    {
                        "description": "Permit all access, even when not authorized.\n\n @return whether to permit access for anybody",
                        "key": "permit-all",
                        "method": "io.helidon.webserver.observe.config.ConfigObserverConfig.Builder#permitAll(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.webserver.observe.health",
        "types": [
            {
                "annotatedType": "io.helidon.webserver.observe.health.HealthObserverConfig",
                "prefix": "health",
                "type": "io.helidon.webserver.observe.health.HealthObserver",
                "standalone": true,
                "producers": [
                    "io.helidon.webserver.observe.health.HealthObserverConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.webserver.observe.health.HealthObserverConfig#builder()",
                    "io.helidon.webserver.observe.health.HealthObserver#create(io.helidon.webserver.observe.health.HealthObserverConfig)"
                ],
                "provides": [
                    "io.helidon.webserver.observe.spi.ObserveProvider"
                ],
                "options": [
                    {
                        "defaultValue": "health",
                        "description": "",
                        "key": "endpoint",
                        "method": "io.helidon.webserver.observe.health.HealthObserverConfig.Builder#endpoint(java.lang.String)"
                    },
                    {
                        "defaultValue": "false",
                        "description": "Whether details should be printed.\n By default, health only returns a io.helidon.http.Status#NO_CONTENT_204 for success,\n io.helidon.http.Status#SERVICE_UNAVAILABLE_503 for health down,\n and io.helidon.http.Status#INTERNAL_SERVER_ERROR_500 in case of error with no entity.\n When details are enabled, health returns io.helidon.http.Status#OK_200 for success, same codes\n otherwise\n and a JSON entity with detailed information about each health check executed.\n\n @return set to `true` to enable details",
                        "key": "details",
                        "method": "io.helidon.webserver.observe.health.HealthObserverConfig.Builder#details(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether to use services discovered by java.util.ServiceLoader.\n By default, all io.helidon.health.spi.HealthCheckProvider based health checks are added.\n\n @return set to `false` to disable discovery",
                        "key": "use-system-services",
                        "method": "io.helidon.webserver.observe.health.HealthObserverConfig.Builder#useSystemServices(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.webserver.observe",
        "types": [
            {
                "annotatedType": "io.helidon.webserver.observe.ObserverConfigBase",
                "type": "io.helidon.webserver.observe.ObserverConfigBase",
                "producers": [
                    "io.helidon.webserver.observe.ObserverConfigBase#create(io.helidon.common.config.Config)",
                    "io.helidon.webserver.observe.ObserverConfigBase#builder()"
                ],
                "options": [
                    {
                        "defaultValue": "true",
                        "description": "Whether this observer is enabled.\n\n @return `false` to disable observer",
                        "key": "enabled",
                        "method": "io.helidon.webserver.observe.ObserverConfigBase.Builder#enabled(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.webserver.observe.ObserveFeatureConfig",
                "prefix": "observe",
                "type": "io.helidon.webserver.observe.ObserveFeature",
                "producers": [
                    "io.helidon.webserver.observe.ObserveFeatureConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.webserver.observe.ObserveFeatureConfig#builder()",
                    "io.helidon.webserver.observe.ObserveFeature#create(io.helidon.webserver.observe.ObserveFeatureConfig)"
                ],
                "provides": [
                    "io.helidon.webserver.spi.ServerFeatureProvider"
                ],
                "options": [
                    {
                        "defaultValue": "@io.helidon.cors.CrossOriginConfig@.create()",
                        "description": "Cors support inherited by each observe provider, unless explicitly configured.\n\n @return cors support to use",
                        "key": "cors",
                        "method": "io.helidon.webserver.observe.ObserveFeatureConfig.Builder#cors(io.helidon.cors.CrossOriginConfig)",
                        "type": "io.helidon.cors.CrossOriginConfig"
                    },
                    {
                        "defaultValue": "/observe",
                        "description": "Root endpoint to use for observe providers. By default, all observe endpoint are under this root endpoint.\n <p>\n Example:\n <br>\n If root endpoint is `/observe` (the default), and default health endpoint is `health` (relative),\n health endpoint would be `/observe/health`.\n\n @return endpoint to use",
                        "key": "endpoint",
                        "method": "io.helidon.webserver.observe.ObserveFeatureConfig.Builder#endpoint(java.lang.String)"
                    },
                    {
                        "description": "Sockets the observability endpoint should be exposed on. If not defined, defaults to the default socket\n ({@value io.helidon.webserver.WebServer#DEFAULT_SOCKET_NAME}.\n Each observer may have its own configuration of sockets that are relevant to it, this only controls the endpoints!\n\n @return list of sockets to register observe endpoint on",
                        "key": "sockets",
                        "kind": "LIST",
                        "method": "io.helidon.webserver.observe.ObserveFeatureConfig.Builder#sockets(java.util.List<java.lang.String>)"
                    },
                    {
                        "defaultValue": "80.0",
                        "description": "Change the weight of this feature. This may change the order of registration of this feature.\n By default, observability weight is {@value ObserveFeature#WEIGHT} so it is registered after routing.\n\n @return weight to use",
                        "key": "weight",
                        "method": "io.helidon.webserver.observe.ObserveFeatureConfig.Builder#weight(double)",
                        "type": "java.lang.Double"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether the observe support is enabled.\n\n @return `false` to disable observe feature",
                        "key": "enabled",
                        "method": "io.helidon.webserver.observe.ObserveFeatureConfig.Builder#enabled(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Observers to use with this observe features.\n Each observer type is registered only once, unless it uses a custom name (default name is the same as the type).\n\n @return list of observers to use in this feature",
                        "key": "observers",
                        "kind": "LIST",
                        "method": "io.helidon.webserver.observe.ObserveFeatureConfig.Builder#observers(java.util.List<io.helidon.webserver.observe.spi.Observer>)",
                        "providerType": "io.helidon.webserver.observe.spi.ObserveProvider",
                        "type": "io.helidon.webserver.observe.spi.Observer",
                        "provider": true
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.webserver.observe.info",
        "types": [
            {
                "annotatedType": "io.helidon.webserver.observe.info.InfoObserverConfig",
                "type": "io.helidon.webserver.observe.info.InfoObserver",
                "producers": [
                    "io.helidon.webserver.observe.info.InfoObserverConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.webserver.observe.info.InfoObserverConfig#builder()",
                    "io.helidon.webserver.observe.info.InfoObserver#create(io.helidon.webserver.observe.info.InfoObserverConfig)"
                ],
                "provides": [
                    "io.helidon.webserver.observe.spi.ObserveProvider"
                ],
                "options": [
                    {
                        "defaultValue": "info",
                        "description": "",
                        "key": "endpoint",
                        "method": "io.helidon.webserver.observe.info.InfoObserverConfig.Builder#endpoint(java.lang.String)"
                    },
                    {
                        "description": "Values to be exposed using this observability endpoint.\n\n @return value map",
                        "key": "values",
                        "kind": "MAP",
                        "method": "io.helidon.webserver.observe.info.InfoObserverConfig.Builder#values(java.util.Map<java.lang.String, java.lang.String>)"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.webserver.observe.log",
        "types": [
            {
                "annotatedType": "io.helidon.webserver.observe.log.LogStreamConfig",
                "type": "io.helidon.webserver.observe.log.LogStreamConfig",
                "producers": [
                    "io.helidon.webserver.observe.log.LogStreamConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.webserver.observe.log.LogStreamConfig#builder()"
                ],
                "options": [
                    {
                        "defaultValue": "PT5S",
                        "description": "How long to wait before we send the idle message, to make sure we keep the stream alive.\n\n @return if no messages appear within this duration, and idle message will be sent\n @see #idleString()",
                        "key": "idle-message-timeout",
                        "method": "io.helidon.webserver.observe.log.LogStreamConfig.Builder#idleMessageTimeout(java.time.Duration)",
                        "type": "java.time.Duration"
                    },
                    {
                        "defaultValue": "100",
                        "description": "Length of the in-memory queue that buffers log messages from loggers before sending them over the network.\n If the messages are produced faster than we can send them to client, excess messages are DISCARDED, and will not\n be sent.\n\n @return size of the in-memory queue for log messages",
                        "key": "queue-size",
                        "method": "io.helidon.webserver.observe.log.LogStreamConfig.Builder#queueSize(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "@io.helidon.http.HttpMediaTypes@.PLAINTEXT_UTF_8",
                        "description": "",
                        "key": "content-type",
                        "method": "io.helidon.webserver.observe.log.LogStreamConfig.Builder#contentType(io.helidon.http.HttpMediaType)",
                        "type": "io.helidon.http.HttpMediaType"
                    },
                    {
                        "defaultValue": "%\n",
                        "description": "String sent when there are no log messages within the #idleMessageTimeout().\n\n @return string to write over the network when no log messages are received",
                        "key": "idle-string",
                        "method": "io.helidon.webserver.observe.log.LogStreamConfig.Builder#idleString(java.lang.String)"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether stream is enabled.\n\n @return whether to allow streaming of log statements",
                        "key": "enabled",
                        "method": "io.helidon.webserver.observe.log.LogStreamConfig.Builder#enabled(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.webserver.observe.log.LogObserverConfig",
                "type": "io.helidon.webserver.observe.log.LogObserver",
                "producers": [
                    "io.helidon.webserver.observe.log.LogObserverConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.webserver.observe.log.LogObserverConfig#builder()",
                    "io.helidon.webserver.observe.log.LogObserver#create(io.helidon.webserver.observe.log.LogObserverConfig)"
                ],
                "provides": [
                    "io.helidon.webserver.observe.spi.ObserveProvider"
                ],
                "options": [
                    {
                        "defaultValue": "log",
                        "description": "",
                        "key": "endpoint",
                        "method": "io.helidon.webserver.observe.log.LogObserverConfig.Builder#endpoint(java.lang.String)"
                    },
                    {
                        "defaultValue": "@io.helidon.webserver.observe.log.LogStreamConfig@.create()",
                        "description": "Configuration of log stream.\n\n @return log stream configuration",
                        "key": "stream",
                        "method": "io.helidon.webserver.observe.log.LogObserverConfig.Builder#stream(io.helidon.webserver.observe.log.LogStreamConfig)",
                        "type": "io.helidon.webserver.observe.log.LogStreamConfig"
                    },
                    {
                        "description": "Permit all access, even when not authorized.\n\n @return whether to permit access for anybody",
                        "key": "permit-all",
                        "method": "io.helidon.webserver.observe.log.LogObserverConfig.Builder#permitAll(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.webserver.http2",
        "types": [
            {
                "annotatedType": "io.helidon.webserver.http2.Http2Config",
                "type": "io.helidon.webserver.http2.Http2Config",
                "producers": [
                    "io.helidon.webserver.http2.Http2Config#create(io.helidon.common.config.Config)",
                    "io.helidon.webserver.http2.Http2Config#builder()"
                ],
                "provides": [
                    "io.helidon.webserver.spi.ProtocolConfig"
                ],
                "options": [
                    {
                        "defaultValue": "8192",
                        "description": "Maximum number of concurrent streams that the server will allow.\n Defaults to `8192`. This limit is directional: it applies to the number of streams that the sender\n permits the receiver to create.\n It is recommended that this value be no smaller than 100 to not unnecessarily limit parallelism\n See RFC 9113 section 6.5.2 for details.\n\n @return maximal number of concurrent streams",
                        "key": "max-concurrent-streams",
                        "method": "io.helidon.webserver.http2.Http2Config.Builder#maxConcurrentStreams(long)",
                        "type": "java.lang.Long"
                    },
                    {
                        "defaultValue": "PT10S",
                        "description": "Period for counting rapid resets(stream RST sent by client before any data have been sent by server).\n Default value is `PT10S`.\n\n @return duration\n @see <a href=\"https://nvd.nist.gov/vuln/detail/CVE-2023-44487\">CVE-2023-44487</a>\n @see <a href=\"https://en.wikipedia.org/wiki/ISO_8601#Durations\">ISO_8601 Durations</a>",
                        "key": "rapid-reset-check-period",
                        "method": "io.helidon.webserver.http2.Http2Config.Builder#rapidResetCheckPeriod(java.time.Duration)",
                        "type": "java.time.Duration"
                    },
                    {
                        "defaultValue": "100",
                        "description": "Maximum number of rapid resets(stream RST sent by client before any data have been sent by server).\n When reached within #rapidResetCheckPeriod(), GOAWAY is sent to client and connection is closed.\n Default value is `100`.\n\n @return maximum number of rapid resets\n @see <a href=\"https://nvd.nist.gov/vuln/detail/CVE-2023-44487\">CVE-2023-44487</a>",
                        "key": "max-rapid-resets",
                        "method": "io.helidon.webserver.http2.Http2Config.Builder#maxRapidResets(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "16384",
                        "description": "The size of the largest frame payload that the sender is willing to receive in bytes.\n Default value is `16384` and maximum value is 2<sup>24</sup>-1 = 16777215 bytes.\n See RFC 9113 section 6.5.2 for details.\n\n @return maximal frame size",
                        "key": "max-frame-size",
                        "method": "io.helidon.webserver.http2.Http2Config.Builder#maxFrameSize(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "false",
                        "description": "Whether to send error message over HTTP to client.\n Defaults to `false`, as exception message may contain internal information that could be used as an\n attack vector. Use with care and in cases where both server and clients are under your full control (such as for\n testing).\n\n @return whether to send error messages over the network",
                        "key": "send-error-details",
                        "method": "io.helidon.webserver.http2.Http2Config.Builder#sendErrorDetails(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "8192",
                        "description": "The maximum field section size that the sender is prepared to accept in bytes.\n See RFC 9113 section 6.5.2 for details.\n Default is 8192.\n\n @return maximal header list size in bytes",
                        "key": "max-header-list-size",
                        "method": "io.helidon.webserver.http2.Http2Config.Builder#maxHeaderListSize(long)",
                        "type": "java.lang.Long"
                    },
                    {
                        "description": "Requested URI discovery settings.\n\n @return settings for computing the requested URI",
                        "key": "requested-uri-discovery",
                        "method": "io.helidon.webserver.http2.Http2Config.Builder#requestedUriDiscovery(io.helidon.http.RequestedUriDiscoveryContext)",
                        "type": "io.helidon.http.RequestedUriDiscoveryContext"
                    },
                    {
                        "defaultValue": "1048576",
                        "description": "This setting indicates the sender's maximum window size in bytes for stream-level flow control.\n Default and maximum value is 2<sup>31</sup>-1 = 2147483647 bytes. This setting affects the window size\n of HTTP/2 connection.\n Any value greater than 2147483647 causes an error. Any value smaller than initial window size causes an error.\n See RFC 9113 section 6.9.1 for details.\n\n @return maximum window size in bytes",
                        "key": "initial-window-size",
                        "method": "io.helidon.webserver.http2.Http2Config.Builder#initialWindowSize(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "PT0.1S",
                        "description": "Outbound flow control blocking timeout configured as java.time.Duration\n or text in ISO-8601 format.\n Blocking timeout defines an interval to wait for the outbound window size changes(incoming window updates)\n before the next blocking iteration.\n Default value is `PT0.1S`.\n\n <table>\n     <caption><b>ISO_8601 format examples:</b></caption>\n     <tr><th>PT0.1S</th><th>100 milliseconds</th></tr>\n     <tr><th>PT0.5S</th><th>500 milliseconds</th></tr>\n     <tr><th>PT2S</th><th>2 seconds</th></tr>\n </table>\n\n @return duration\n @see <a href=\"https://en.wikipedia.org/wiki/ISO_8601#Durations\">ISO_8601 Durations</a>",
                        "key": "flow-control-timeout",
                        "method": "io.helidon.webserver.http2.Http2Config.Builder#flowControlTimeout(java.time.Duration)",
                        "type": "java.time.Duration"
                    },
                    {
                        "defaultValue": "true",
                        "description": "If set to false, any path is accepted (even containing illegal characters).\n\n @return whether to validate path",
                        "key": "validate-path",
                        "method": "io.helidon.webserver.http2.Http2Config.Builder#validatePath(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "10",
                        "description": "Maximum number of consecutive empty frames allowed on connection.\n\n @return max number of consecutive empty frames",
                        "key": "max-empty-frames",
                        "method": "io.helidon.webserver.http2.Http2Config.Builder#maxEmptyFrames(int)",
                        "type": "java.lang.Integer"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.webserver",
        "types": [
            {
                "annotatedType": "io.helidon.webserver.WebServerConfig",
                "prefix": "server",
                "type": "io.helidon.webserver.WebServer",
                "standalone": true,
                "inherits": [
                    "io.helidon.webserver.ListenerConfig"
                ],
                "producers": [
                    "io.helidon.webserver.WebServerConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.webserver.WebServerConfig#builder()",
                    "io.helidon.webserver.WebServer#create(io.helidon.webserver.WebServerConfig)"
                ],
                "options": [
                    {
                        "description": "Server features allow customization of the server, listeners, or routings.\n\n @return server features",
                        "key": "features",
                        "kind": "LIST",
                        "method": "io.helidon.webserver.WebServerConfig.Builder#features(java.util.List<io.helidon.webserver.spi.ServerFeature>)",
                        "providerType": "io.helidon.webserver.spi.ServerFeatureProvider",
                        "type": "io.helidon.webserver.spi.ServerFeature",
                        "provider": true
                    },
                    {
                        "description": "Socket configurations.\n Note that socket named {@value WebServer#DEFAULT_SOCKET_NAME} cannot be used,\n configure the values on the server directly.\n\n @return map of listener configurations, except for the default one",
                        "key": "sockets",
                        "kind": "MAP",
                        "method": "io.helidon.webserver.WebServerConfig.Builder#sockets(java.util.Map<java.lang.String, io.helidon.webserver.ListenerConfig>)",
                        "type": "io.helidon.webserver.ListenerConfig"
                    },
                    {
                        "defaultValue": "true",
                        "description": "When true the webserver registers a shutdown hook with the JVM Runtime.\n <p>\n Defaults to true. Set this to false such that a shutdown hook is not registered.\n\n @return whether to register a shutdown hook",
                        "key": "shutdown-hook",
                        "method": "io.helidon.webserver.WebServerConfig.Builder#shutdownHook(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.webserver.ConnectionConfig",
                "type": "io.helidon.webserver.ConnectionConfig",
                "producers": [
                    "io.helidon.webserver.ConnectionConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.webserver.ConnectionConfig#builder()"
                ],
                "options": [
                    {
                        "defaultValue": "PT30S",
                        "description": "Read timeout.\n Default is {@value #DEFAULT_READ_TIMEOUT_DURATION}\n\n @return read timeout",
                        "key": "read-timeout",
                        "method": "io.helidon.webserver.ConnectionConfig.Builder#readTimeout(java.time.Duration)",
                        "type": "java.time.Duration"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Configure socket keep alive.\n Default is `true`.\n\n @return keep alive\n @see java.net.StandardSocketOptions#SO_KEEPALIVE",
                        "key": "keep-alive",
                        "method": "io.helidon.webserver.ConnectionConfig.Builder#keepAlive(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "PT10S",
                        "description": "Connect timeout.\n Default is {@value #DEFAULT_CONNECT_TIMEOUT_DURATION}.\n\n @return connect timeout",
                        "key": "connect-timeout",
                        "method": "io.helidon.webserver.ConnectionConfig.Builder#connectTimeout(java.time.Duration)",
                        "type": "java.time.Duration"
                    },
                    {
                        "defaultValue": "32768",
                        "description": "Socket receive buffer size.\n Default is {@value #DEFAULT_SO_BUFFER_SIZE}.\n\n @return buffer size, in bytes\n @see java.net.StandardSocketOptions#SO_RCVBUF",
                        "key": "receive-buffer-size",
                        "method": "io.helidon.webserver.ConnectionConfig.Builder#receiveBufferSize(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Socket reuse address.\n Default is `true`.\n\n @return whether to reuse address\n @see java.net.StandardSocketOptions#SO_REUSEADDR",
                        "key": "reuse-address",
                        "method": "io.helidon.webserver.ConnectionConfig.Builder#reuseAddress(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "false",
                        "description": "Disable <a href=\"https://en.wikipedia.org/wiki/Nagle%27s_algorithm\">Nagle's algorithm</a> by setting\n TCP_NODELAY to true. This can result in better performance on Mac or newer linux kernels for some\n payload types.\n Default is `false`.\n\n @return whether to use TCP_NODELAY, defaults to `false`\n @see java.net.StandardSocketOptions#TCP_NODELAY",
                        "key": "tcp-no-delay",
                        "method": "io.helidon.webserver.ConnectionConfig.Builder#tcpNoDelay(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "32768",
                        "description": "Socket send buffer size.\n Default is {@value #DEFAULT_SO_BUFFER_SIZE}.\n\n @return buffer size, in bytes\n @see java.net.StandardSocketOptions#SO_SNDBUF",
                        "key": "send-buffer-size",
                        "method": "io.helidon.webserver.ConnectionConfig.Builder#sendBufferSize(int)",
                        "type": "java.lang.Integer"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.webserver.http1.Http1Config",
                "type": "io.helidon.webserver.http1.Http1Config",
                "producers": [
                    "io.helidon.webserver.http1.Http1Config#create(io.helidon.common.config.Config)",
                    "io.helidon.webserver.http1.Http1Config#builder()"
                ],
                "provides": [
                    "io.helidon.webserver.spi.ProtocolConfig"
                ],
                "options": [
                    {
                        "defaultValue": "false",
                        "description": "Whether to validate headers.\n If set to false, any value is accepted, otherwise validates headers + known headers\n are validated by format\n (content length is always validated as it is part of protocol processing (other headers may be validated if\n features use them)).\n <p>\n     Defaults to `false` as user has control on the header creation.\n </p>\n\n @return whether to validate headers",
                        "key": "validate-response-headers",
                        "method": "io.helidon.webserver.http1.Http1Config.Builder#validateResponseHeaders(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "2048",
                        "description": "Maximal size of received HTTP prologue (GET /path HTTP/1.1).\n\n @return maximal size in bytes",
                        "key": "max-prologue-length",
                        "method": "io.helidon.webserver.http1.Http1Config.Builder#maxPrologueLength(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Logging of sent packets. Uses trace and debug levels on logger of\n Http1LoggingConnectionListener with suffix of `.send``.\n\n @return `true` if logging should be enabled for sent packets, `false` if no logging should be done",
                        "key": "send-log",
                        "method": "io.helidon.webserver.http1.Http1Config.Builder#sendLog(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether to validate headers.\n If set to false, any value is accepted, otherwise validates headers + known headers\n are validated by format\n (content length is always validated as it is part of protocol processing (other headers may be validated if\n features use them)).\n <p>\n     Defaults to `true`.\n </p>\n\n @return whether to validate headers",
                        "key": "validate-request-headers",
                        "method": "io.helidon.webserver.http1.Http1Config.Builder#validateRequestHeaders(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Requested URI discovery settings.\n\n @return settings for computing the requested URI",
                        "key": "requested-uri-discovery",
                        "method": "io.helidon.webserver.http1.Http1Config.Builder#requestedUriDiscovery(io.helidon.http.RequestedUriDiscoveryContext)",
                        "type": "io.helidon.http.RequestedUriDiscoveryContext"
                    },
                    {
                        "defaultValue": "16384",
                        "description": "Maximal size of received headers in bytes.\n\n @return maximal header size",
                        "key": "max-headers-size",
                        "method": "io.helidon.webserver.http1.Http1Config.Builder#maxHeadersSize(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "true",
                        "description": "If set to false, any path is accepted (even containing illegal characters).\n\n @return whether to validate path",
                        "key": "validate-path",
                        "method": "io.helidon.webserver.http1.Http1Config.Builder#validatePath(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Logging of received packets. Uses trace and debug levels on logger of\n Http1LoggingConnectionListener with suffix of `.recv``.\n\n @return `true` if logging should be enabled for received packets, `false` if no logging should be done",
                        "key": "recv-log",
                        "method": "io.helidon.webserver.http1.Http1Config.Builder#receiveLog(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "false",
                        "description": "When true WebServer answers to expect continue with 100 continue immediately,\n not waiting for user to actually request the data.\n\n @return if `true` answer with 100 continue immediately after expect continue",
                        "key": "continue-immediately",
                        "method": "io.helidon.webserver.http1.Http1Config.Builder#continueImmediately(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.webserver.ListenerConfig",
                "type": "io.helidon.webserver.ListenerConfig",
                "producers": [
                    "io.helidon.webserver.ListenerConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.webserver.ListenerConfig#builder()"
                ],
                "options": [
                    {
                        "defaultValue": "-1",
                        "description": "Limits the number of connections that can be opened at a single point in time.\n Defaults to `-1`, meaning \"unlimited\" - what the system allows.\n\n @return number of TCP connections that can be opened to this listener, regardless of protocol",
                        "key": "max-tcp-connections",
                        "method": "io.helidon.webserver.ListenerConfig.Builder#maxTcpConnections(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "0",
                        "description": "Number of buffers queued for write operations.\n\n @return maximal number of queued writes, defaults to 0",
                        "key": "write-queue-length",
                        "method": "io.helidon.webserver.ListenerConfig.Builder#writeQueueLength(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "512",
                        "description": "Initial buffer size in bytes of java.io.BufferedOutputStream created internally to\n write data to a socket connection. Default is `512`.\n\n @return initial buffer size used for writing",
                        "key": "write-buffer-size",
                        "method": "io.helidon.webserver.ListenerConfig.Builder#writeBufferSize(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "PT0.5S",
                        "description": "Grace period in ISO 8601 duration format to allow running tasks to complete before listener's shutdown.\n Default is `500` milliseconds.\n <p>Configuration file values example: `PT0.5S`, `PT2S`.\n\n @return grace period",
                        "key": "shutdown-grace-period",
                        "method": "io.helidon.webserver.ListenerConfig.Builder#shutdownGracePeriod(java.time.Duration)",
                        "type": "java.time.Duration"
                    },
                    {
                        "description": "Configure the listener specific io.helidon.http.encoding.ContentEncodingContext.\n This method discards all previously registered ContentEncodingContext.\n If no content encoding context is registered, content encoding context of the webserver would be used.\n\n @return content encoding context",
                        "key": "content-encoding",
                        "method": "io.helidon.webserver.ListenerConfig.Builder#contentEncoding(java.util.Optional<io.helidon.http.encoding.ContentEncodingContext>)",
                        "type": "io.helidon.http.encoding.ContentEncodingContext"
                    },
                    {
                        "defaultValue": "PT5M",
                        "description": "How long should we wait before closing a connection that has no traffic on it.\n Defaults to `PT5M` (5 minutes). Note that the timestamp is refreshed max. once per second, so this setting\n would be useless if configured for shorter periods of time (also not a very good support for connection keep alive,\n if the connections are killed so soon anyway).\n\n @return timeout of idle connections",
                        "key": "idle-connection-timeout",
                        "method": "io.helidon.webserver.ListenerConfig.Builder#idleConnectionTimeout(java.time.Duration)",
                        "type": "java.time.Duration"
                    },
                    {
                        "defaultValue": "-1",
                        "description": "Limits the number of requests that can be executed at the same time (the number of active virtual threads of requests).\n Defaults to `-1`, meaning \"unlimited\" - what the system allows.\n Also make sure that this number is higher than the expected time it takes to handle a single request in your application,\n as otherwise you may stop in-progress requests.\n\n @return number of requests that can be processed on this listener, regardless of protocol",
                        "key": "max-concurrent-requests",
                        "method": "io.helidon.webserver.ListenerConfig.Builder#maxConcurrentRequests(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "description": "Requested URI discovery context.\n\n @return discovery context",
                        "key": "requested-uri-discovery",
                        "method": "io.helidon.webserver.ListenerConfig.Builder#requestedUriDiscoveryContext(java.util.Optional<io.helidon.http.RequestedUriDiscoveryContext>)",
                        "type": "io.helidon.http.RequestedUriDiscoveryContext"
                    },
                    {
                        "description": "Configure the listener specific io.helidon.http.media.MediaContext.\n This method discards all previously registered MediaContext.\n If no media context is registered, media context of the webserver would be used.\n\n @return media context",
                        "key": "media-context",
                        "method": "io.helidon.webserver.ListenerConfig.Builder#mediaContext(java.util.Optional<io.helidon.http.media.MediaContext>)",
                        "type": "io.helidon.http.media.MediaContext"
                    },
                    {
                        "defaultValue": "131072",
                        "description": "If the entity is expected to be smaller that this number of bytes, it would be buffered in memory to optimize\n performance when writing it.\n If bigger, streaming will be used.\n <p>\n Note that for some entity types we cannot use streaming, as they are already fully in memory (String, byte[]), for such\n cases, this option is ignored.\n <p>\n Default is 128Kb.\n\n @return maximal number of bytes to buffer in memory for supported writers",
                        "key": "max-in-memory-entity",
                        "method": "io.helidon.webserver.ListenerConfig.Builder#maxInMemoryEntity(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "-1",
                        "description": "Maximal number of bytes an entity may have.\n If io.helidon.http.HeaderNames#CONTENT_LENGTH is used, this is checked immediately,\n if io.helidon.http.HeaderValues#TRANSFER_ENCODING_CHUNKED is used, we will fail when the\n number of bytes read would exceed the max payload size.\n Defaults to unlimited (`-1`).\n\n @return maximal number of bytes of entity",
                        "key": "max-payload-size",
                        "method": "io.helidon.webserver.ListenerConfig.Builder#maxPayloadSize(long)",
                        "type": "java.lang.Long"
                    },
                    {
                        "defaultValue": "1024",
                        "description": "Accept backlog.\n\n @return backlog",
                        "key": "backlog",
                        "method": "io.helidon.webserver.ListenerConfig.Builder#backlog(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "0",
                        "description": "Port of the default socket.\n If configured to `0` (the default), server starts on a random port.\n\n @return port to listen on (for the default socket)",
                        "key": "port",
                        "method": "io.helidon.webserver.ListenerConfig.Builder#port(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "description": "Listener receive buffer size.\n\n @return buffer size in bytes",
                        "key": "receive-buffer-size",
                        "method": "io.helidon.webserver.ListenerConfig.Builder#receiveBufferSize(java.util.Optional<java.lang.Integer>)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "description": "Options for connections accepted by this listener.\n This is not used to setup server connection.\n\n @return socket options",
                        "key": "connection-options",
                        "method": "io.helidon.webserver.ListenerConfig.Builder#connectionOptions(io.helidon.common.socket.SocketOptions)",
                        "type": "io.helidon.common.socket.SocketOptions"
                    },
                    {
                        "defaultValue": "0.0.0.0",
                        "description": "Host of the default socket. Defaults to all host addresses (`0.0.0.0`).\n\n @return host address to listen on (for the default socket)",
                        "key": "host",
                        "method": "io.helidon.webserver.ListenerConfig.Builder#host(java.lang.String)"
                    },
                    {
                        "defaultValue": "@default",
                        "description": "Name of this socket. Defaults to `@default`.\n Must be defined if more than one socket is needed.\n\n @return name of the socket",
                        "key": "name",
                        "method": "io.helidon.webserver.ListenerConfig.Builder#name(java.lang.String)"
                    },
                    {
                        "defaultValue": "PT2M",
                        "description": "How often should we check for #idleConnectionTimeout().\n Defaults to `PT2M` (2 minutes).\n\n @return period of checking for idle connections",
                        "key": "idle-connection-period",
                        "method": "io.helidon.webserver.ListenerConfig.Builder#idleConnectionPeriod(java.time.Duration)",
                        "type": "java.time.Duration"
                    },
                    {
                        "description": "Listener TLS configuration.\n\n @return tls of this configuration",
                        "key": "tls",
                        "method": "io.helidon.webserver.ListenerConfig.Builder#tls(java.util.Optional<io.helidon.common.tls.Tls>)",
                        "type": "io.helidon.common.tls.Tls"
                    },
                    {
                        "description": "Configuration of protocols. This may be either protocol selectors, or protocol upgraders from HTTP/1.1.\n As the order is not important (providers are ordered by weight by default), we can use a configuration as an object,\n such as:\n <pre>\n protocols:\n   providers:\n     http_1_1:\n       max-prologue-length: 8192\n     http_2:\n       max-frame-size: 4096\n     websocket:\n       ....\n </pre>\n\n @return all defined protocol configurations, loaded from service loader by default",
                        "key": "protocols",
                        "kind": "LIST",
                        "method": "io.helidon.webserver.ListenerConfig.Builder#protocols(java.util.List<io.helidon.webserver.spi.ProtocolConfig>)",
                        "providerType": "io.helidon.webserver.spi.ProtocolConfigProvider",
                        "type":         "io.helidon.webserver.spi.ProtocolConfig",
                        "provider": true
                    },
                    {
                        "description": "Configuration of a connection (established from client against our server).\n\n @return connection configuration",
                        "key": "connection-config",
                        "method": "io.helidon.webserver.ListenerConfig.Builder#connectionConfig(java.util.Optional<io.helidon.webserver.ConnectionConfig>)",
                        "type": "io.helidon.webserver.ConnectionConfig"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.servicecommon",
        "types": [
            {
                "annotatedType": "io.helidon.webserver.servicecommon.HelidonFeatureSupport.Builder",
                "type": "io.helidon.webserver.servicecommon.HelidonFeatureSupport.Builder",
                "options": [
                    {
                        "description": "Set the root context for the REST API of the service.",
                        "key": "web-context",
                        "method": "io.helidon.webserver.servicecommon.HelidonFeatureSupport.Builder#webContext(java.lang.String)"
                    },
                    {
                        "description": "Set the CORS config from the specified `CrossOriginConfig` object.",
                        "key": "cross-origin-config",
                        "method": "io.helidon.webserver.servicecommon.HelidonFeatureSupport.Builder#crossOriginConfig(io.helidon.cors.CrossOriginConfig)",
                        "type": "io.helidon.cors.CrossOriginConfig"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.webserver.servicecommon.RestServiceSettings.Builder",
                "type": "io.helidon.webserver.servicecommon.RestServiceSettings.Builder",
                "options": [
                    {
                        "description": "Sets the web context to use for the service's endpoint.",
                        "key": "web-context",
                        "method": "io.helidon.webserver.servicecommon.RestServiceSettings.Builder#webContext(java.lang.String)",
                        "merge": true
                    },
                    {
                        "description": "Sets the routing name to use for setting up the service's endpoint.",
                        "key": "routing",
                        "method": "io.helidon.webserver.servicecommon.RestServiceSettings.Builder#routing(java.lang.String)",
                        "merge": true
                    },
                    {
                        "description": "Sets the cross-origin config builder for use in establishing CORS support for the service endpoints.",
                        "key": "cors",
                        "kind": "MAP",
                        "method": "io.helidon.webserver.servicecommon.RestServiceSettings.Builder#crossOriginConfig(io.helidon.cors.CrossOriginConfig.Builder)",
                        "type": "io.helidon.cors.CrossOriginConfig"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Is this service enabled or not.",
                        "key": "enabled",
                        "method": "io.helidon.webserver.servicecommon.RestServiceSettings.Builder#enabled(boolean)",
                        "type": "java.lang.Boolean",
                        "merge": true
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.webserver.cors",
        "types": [
            {
                "annotatedType": "io.helidon.webserver.cors.CorsConfig",
                "prefix": "cors",
                "type": "io.helidon.webserver.cors.CorsFeature",
                "producers": [
                    "io.helidon.webserver.cors.CorsConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.webserver.cors.CorsConfig#builder()",
                    "io.helidon.webserver.cors.CorsFeature#create(io.helidon.webserver.cors.CorsConfig)"
                ],
                "provides": [
                    "io.helidon.webserver.spi.ServerFeatureProvider"
                ],
                "options": [
                    {
                        "description": "List of sockets to register this feature on. If empty, it would get registered on all sockets.\n\n @return socket names to register on, defaults to empty (all available sockets)",
                        "key": "sockets",
                        "kind": "LIST",
                        "method": "io.helidon.webserver.cors.CorsConfig.Builder#sockets(java.util.Set<java.lang.String>)"
                    },
                    {
                        "defaultValue": "950.0",
                        "description": "Weight of the CORS feature. As it is used by other features, the default is quite high:\n {@value CorsFeature#WEIGHT}.\n\n @return weight of the feature",
                        "key": "weight",
                        "method": "io.helidon.webserver.cors.CorsConfig.Builder#weight(double)",
                        "type": "java.lang.Double"
                    },
                    {
                        "description": "This feature can be disabled.\n\n @return whether the feature is enabled",
                        "key": "enabled",
                        "method": "io.helidon.webserver.cors.CorsConfig.Builder#enabled(boolean)",
                        "type": "java.lang.Boolean",
                        "required": true
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.common.configurable",
        "types": [
            {
                "annotatedType": "io.helidon.common.configurable.ResourceConfig",
                "type": "io.helidon.common.configurable.Resource",
                "producers": [
                    "io.helidon.common.configurable.ResourceConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.common.configurable.ResourceConfig#builder()",
                    "io.helidon.common.configurable.Resource#create(io.helidon.common.configurable.ResourceConfig)"
                ],
                "options": [
                    {
                        "description": "Resource is located on filesystem.\n\n @return path of the resource",
                        "key": "path",
                        "method": "io.helidon.common.configurable.ResourceConfig.Builder#path(java.util.Optional<java.nio.file.Path>)",
                        "type": "java.nio.file.Path"
                    },
                    {
                        "description": "Resource is located on classpath.\n\n @return classpath location of the resource",
                        "key": "resource-path",
                        "method": "io.helidon.common.configurable.ResourceConfig.Builder#resourcePath(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "description": "Host of the proxy when using URI.\n\n @return proxy host",
                        "key": "proxy-host",
                        "method": "io.helidon.common.configurable.ResourceConfig.Builder#proxyHost(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "description": "Resource is available on a java.net.URI.\n\n @return of the resource\n @see #proxy()\n @see #useProxy()",
                        "key": "uri",
                        "method": "io.helidon.common.configurable.ResourceConfig.Builder#uri(java.util.Optional<java.net.URI>)",
                        "type": "java.net.URI"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether to use proxy. If set to `false`, proxy will not be used even if configured.\n When set to `true` (default), proxy will be used if configured.\n\n @return whether to use proxy if configured",
                        "key": "use-proxy",
                        "method": "io.helidon.common.configurable.ResourceConfig.Builder#useProxy(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Plain content of the resource (text).\n\n @return plain content",
                        "key": "content-plain",
                        "method": "io.helidon.common.configurable.ResourceConfig.Builder#contentPlain(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "defaultValue": "80",
                        "description": "Port of the proxy when using URI.\n\n @return proxy port",
                        "key": "proxy-port",
                        "method": "io.helidon.common.configurable.ResourceConfig.Builder#proxyPort(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "",
                        "description": "Description of this resource when configured through plain text or binary.\n\n @return description",
                        "key": "description",
                        "method": "io.helidon.common.configurable.ResourceConfig.Builder#description(java.lang.String)"
                    },
                    {
                        "description": "Binary content of the resource (base64 encoded).\n\n @return binary content",
                        "key": "content",
                        "method": "io.helidon.common.configurable.ResourceConfig.Builder#content(java.util.Optional<java.lang.String>)"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.common.configurable.ScheduledThreadPoolConfig",
                "type": "io.helidon.common.configurable.ScheduledThreadPoolSupplier",
                "producers": [
                    "io.helidon.common.configurable.ScheduledThreadPoolConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.common.configurable.ScheduledThreadPoolConfig#builder()",
                    "io.helidon.common.configurable.ScheduledThreadPoolSupplier#create(io.helidon.common.configurable.ScheduledThreadPoolConfig)"
                ],
                "options": [
                    {
                        "defaultValue": "false",
                        "description": "Whether to prestart core threads in this thread pool executor.\n Defaults to {@value #DEFAULT_PRESTART}.\n\n @return whether to prestart the threads",
                        "key": "prestart",
                        "method": "io.helidon.common.configurable.ScheduledThreadPoolConfig.Builder#prestart(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "helidon-",
                        "description": "Name prefix for threads in this thread pool executor.\n Defaults to {@value #DEFAULT_THREAD_NAME_PREFIX}.\n\n @return prefix of a thread name",
                        "key": "thread-name-prefix",
                        "method": "io.helidon.common.configurable.ScheduledThreadPoolConfig.Builder#threadNamePrefix(java.lang.String)"
                    },
                    {
                        "description": "When configured to `true`, an unbounded virtual executor service (project Loom) will be used.\n <p>\n If enabled, all other configuration options of this executor service are ignored!\n\n @return whether to use virtual threads or not, defaults to `false`",
                        "key": "virtual-threads",
                        "method": "io.helidon.common.configurable.ScheduledThreadPoolConfig.Builder#virtualThreads(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "16",
                        "description": "Core pool size of the thread pool executor.\n Defaults to {@value #DEFAULT_CORE_POOL_SIZE}.\n\n @return corePoolSize see java.util.concurrent.ThreadPoolExecutor#getCorePoolSize()",
                        "key": "core-pool-size",
                        "method": "io.helidon.common.configurable.ScheduledThreadPoolConfig.Builder#corePoolSize(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Is daemon of the thread pool executor.\n Defaults to {@value #DEFAULT_IS_DAEMON}.\n\n @return whether the threads are daemon threads",
                        "key": "is-daemon",
                        "method": "io.helidon.common.configurable.ScheduledThreadPoolConfig.Builder#daemon(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.common.configurable.LruCacheConfig",
                "type": "io.helidon.common.configurable.LruCache",
                "producers": [
                    "io.helidon.common.configurable.LruCacheConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.common.configurable.LruCacheConfig#builder()",
                    "io.helidon.common.configurable.LruCache#create(io.helidon.common.configurable.LruCacheConfig)"
                ],
                "options": [
                    {
                        "defaultValue": "10000",
                        "description": "Configure capacity of the cache. Defaults to {@value LruCache#DEFAULT_CAPACITY}.\n\n @return maximal number of records in the cache before the oldest one is removed",
                        "key": "capacity",
                        "method": "io.helidon.common.configurable.LruCacheConfig.Builder#capacity(int)",
                        "type": "java.lang.Integer"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.common.configurable.ThreadPoolConfig",
                "type": "io.helidon.common.configurable.ThreadPoolSupplier",
                "producers": [
                    "io.helidon.common.configurable.ThreadPoolConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.common.configurable.ThreadPoolConfig#builder()",
                    "io.helidon.common.configurable.ThreadPoolSupplier#create(io.helidon.common.configurable.ThreadPoolConfig)"
                ],
                "options": [
                    {
                        "defaultValue": "50",
                        "description": "Max pool size of the thread pool executor.\n Defaults to {@value #DEFAULT_MAX_POOL_SIZE}.\n\n @return maxPoolSize see java.util.concurrent.ThreadPoolExecutor#getMaximumPoolSize()",
                        "key": "max-pool-size",
                        "method": "io.helidon.common.configurable.ThreadPoolConfig.Builder#maxPoolSize(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "PT3M",
                        "description": "Keep alive of the thread pool executor.\n Defaults to {@value #DEFAULT_KEEP_ALIVE}.\n\n @return keep alive see java.util.concurrent.ThreadPoolExecutor#getKeepAliveTime(java.util.concurrent.TimeUnit)",
                        "key": "keep-alive",
                        "method": "io.helidon.common.configurable.ThreadPoolConfig.Builder#keepAlive(java.time.Duration)",
                        "type": "java.time.Duration"
                    },
                    {
                        "description": "Name prefix for threads in this thread pool executor.\n Defaults to {@value #DEFAULT_THREAD_NAME_PREFIX}.\n\n @return prefix of a thread name",
                        "key": "thread-name-prefix",
                        "method": "io.helidon.common.configurable.ThreadPoolConfig.Builder#threadNamePrefix(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Whether to prestart core threads in this thread pool executor.\n Defaults to {@value #DEFAULT_PRESTART}.\n\n @return whether to prestart the threads",
                        "key": "should-prestart",
                        "method": "io.helidon.common.configurable.ThreadPoolConfig.Builder#shouldPrestart(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "When configured to `true`, an unbounded virtual executor service (project Loom) will be used.\n <p>\n If enabled, all other configuration options of this executor service are ignored!\n\n @return whether to use virtual threads or not, defaults to `false`",
                        "key": "virtual-threads",
                        "method": "io.helidon.common.configurable.ThreadPoolConfig.Builder#virtualThreads(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "10",
                        "description": "Core pool size of the thread pool executor.\n Defaults to {@value #DEFAULT_CORE_POOL_SIZE}.\n\n @return corePoolSize see java.util.concurrent.ThreadPoolExecutor#getCorePoolSize()",
                        "key": "core-pool-size",
                        "method": "io.helidon.common.configurable.ThreadPoolConfig.Builder#corePoolSize(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "description": "Name of this thread pool executor.\n\n @return the pool name",
                        "key": "name",
                        "method": "io.helidon.common.configurable.ThreadPoolConfig.Builder#name(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Is daemon of the thread pool executor.\n Defaults to {@value #DEFAULT_IS_DAEMON}.\n\n @return whether the threads are daemon threads",
                        "key": "is-daemon",
                        "method": "io.helidon.common.configurable.ThreadPoolConfig.Builder#daemon(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "1000",
                        "description": "The queue size above which pool growth will be considered if the pool is not fixed size.\n Defaults to {@value #DEFAULT_GROWTH_THRESHOLD}.\n\n @return the growth threshold",
                        "key": "growth-threshold",
                        "method": "io.helidon.common.configurable.ThreadPoolConfig.Builder#growthThreshold(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "10000",
                        "description": "Queue capacity of the thread pool executor.\n Defaults to {@value #DEFAULT_QUEUE_CAPACITY}.\n\n @return capacity of the queue backing the executor",
                        "key": "queue-capacity",
                        "method": "io.helidon.common.configurable.ThreadPoolConfig.Builder#queueCapacity(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "0",
                        "description": "The percentage of task submissions that should result in adding threads, expressed as a value from 1 to 100. The\n rate applies only when all of the following are true:\n <ul>\n <li>the pool size is below the maximum, and</li>\n <li>there are no idle threads, and</li>\n <li>the number of tasks in the queue exceeds the `growthThreshold`</li>\n </ul>\n For example, a rate of 20 means that while these conditions are met one thread will be added for every 5 submitted\n tasks.\n <p>\n Defaults to {@value #DEFAULT_GROWTH_RATE}\n\n @return the growth rate",
                        "key": "growth-rate",
                        "method": "io.helidon.common.configurable.ThreadPoolConfig.Builder#growthRate(int)",
                        "type": "java.lang.Integer"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.common.configurable.AllowListConfig",
                "type": "io.helidon.common.configurable.AllowList",
                "producers": [
                    "io.helidon.common.configurable.AllowListConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.common.configurable.AllowListConfig#builder()",
                    "io.helidon.common.configurable.AllowList#create(io.helidon.common.configurable.AllowListConfig)"
                ],
                "options": [
                    {
                        "defaultValue": "false",
                        "description": "Allows all strings to match (subject to \"deny\" conditions). An `allow.all` setting of `false` does\n not deny all strings but rather represents the absence of a universal match, meaning that other allow and deny settings\n determine the matching outcomes.\n\n @return whether to allow all strings to match (subject to \"deny\" conditions)",
                        "key": "allow.all",
                        "method": "io.helidon.common.configurable.AllowListConfig.Builder#allowAll(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Patterns specifying strings to allow.\n\n @return patterns which allow matching",
                        "key": "allow.pattern",
                        "kind": "LIST",
                        "method": "io.helidon.common.configurable.AllowListConfig.Builder#allowedPatterns(java.util.List<java.util.regex.Pattern>)",
                        "type": "java.util.regex.Pattern"
                    },
                    {
                        "description": "Suffixes specifying strings to deny.\n\n @return suffixes which deny matching",
                        "key": "deny.suffix",
                        "kind": "LIST",
                        "method": "io.helidon.common.configurable.AllowListConfig.Builder#deniedSuffixes(java.util.List<java.lang.String>)"
                    },
                    {
                        "description": "Prefixes specifying strings to allow.\n\n @return prefixes which allow matching",
                        "key": "allow.prefix",
                        "kind": "LIST",
                        "method": "io.helidon.common.configurable.AllowListConfig.Builder#allowedPrefixes(java.util.List<java.lang.String>)"
                    },
                    {
                        "description": "Exact strings to deny.\n\n @return exact strings to allow",
                        "key": "deny.exact",
                        "kind": "LIST",
                        "method": "io.helidon.common.configurable.AllowListConfig.Builder#denied(java.util.List<java.lang.String>)"
                    },
                    {
                        "description": "Patterns specifying strings to deny.\n\n @return patterns which deny matching",
                        "key": "deny.pattern",
                        "kind": "LIST",
                        "method": "io.helidon.common.configurable.AllowListConfig.Builder#deniedPatterns(java.util.List<java.util.regex.Pattern>)",
                        "type": "java.util.regex.Pattern"
                    },
                    {
                        "description": "Exact strings to allow.\n\n @return exact strings to allow",
                        "key": "allow.exact",
                        "kind": "LIST",
                        "method": "io.helidon.common.configurable.AllowListConfig.Builder#allowed(java.util.List<java.lang.String>)"
                    },
                    {
                        "description": "Prefixes specifying strings to deny.\n\n @return prefixes which deny matching",
                        "key": "deny.prefix",
                        "kind": "LIST",
                        "method": "io.helidon.common.configurable.AllowListConfig.Builder#deniedPrefixes(java.util.List<java.lang.String>)"
                    },
                    {
                        "description": "Suffixes specifying strings to allow.\n\n @return suffixes which allow matching",
                        "key": "allow.suffix",
                        "kind": "LIST",
                        "method": "io.helidon.common.configurable.AllowListConfig.Builder#allowedSuffixes(java.util.List<java.lang.String>)"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.common.pki",
        "types": [
            {
                "annotatedType": "io.helidon.common.pki.Keys",
                "type": "io.helidon.common.pki.Keys",
                "producers": [
                    "io.helidon.common.pki.Keys#create(io.helidon.common.config.Config)",
                    "io.helidon.common.pki.Keys#builder()"
                ],
                "options": [
                    {
                        "description": "Configure keys from pem file(s).\n Once the config object is built, this option will ALWAYS be empty. All keys from the keystore will be\n populated to #privateKey(), #publicKey(), #publicCert() etc.\n\n @return pem based definition",
                        "key": "pem",
                        "method": "io.helidon.common.pki.Keys.Builder#pem(java.util.Optional<io.helidon.common.pki.PemKeys>)",
                        "type": "io.helidon.common.pki.PemKeys"
                    },
                    {
                        "description": "Configure keys from a keystore.\n Once the config object is built, this option will ALWAYS be empty. All keys from the keystore will be\n populated to #privateKey(), #publicKey(), #publicCert() etc.\n\n @return keystore configuration",
                        "key": "keystore",
                        "method": "io.helidon.common.pki.Keys.Builder#keystore(java.util.Optional<io.helidon.common.pki.KeystoreKeys>)",
                        "type": "io.helidon.common.pki.KeystoreKeys"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.common.pki.KeystoreKeys",
                "type": "io.helidon.common.pki.KeystoreKeys",
                "producers": [
                    "io.helidon.common.pki.KeystoreKeys#create(io.helidon.common.config.Config)",
                    "io.helidon.common.pki.KeystoreKeys#builder()"
                ],
                "options": [
                    {
                        "defaultValue": "false",
                        "description": "If you want to build a trust store, call this method to add all\n certificates present in the keystore to certificate list.\n\n @return whether this is a trust store",
                        "key": "trust-store",
                        "method": "io.helidon.common.pki.KeystoreKeys.Builder#trustStore(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Alias of X.509 certificate of public key.\n Used to load both the certificate and public key.\n\n @return alias under which the certificate is stored in the keystore",
                        "key": "cert.alias",
                        "method": "io.helidon.common.pki.KeystoreKeys.Builder#certAlias(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "description": "Alias of an X.509 chain.\n\n @return alias of certificate chain in the keystore",
                        "key": "cert-chain.alias",
                        "method": "io.helidon.common.pki.KeystoreKeys.Builder#certChainAlias(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "description": "Keystore resource definition.\n\n @return keystore resource, from file path, classpath, URL etc.",
                        "key": "resource",
                        "method": "io.helidon.common.pki.KeystoreKeys.Builder#keystore(io.helidon.common.configurable.Resource)",
                        "type": "io.helidon.common.configurable.Resource",
                        "required": true
                    },
                    {
                        "description": "Pass-phrase of the keystore (supported with JKS and PKCS12 keystores).\n\n @return keystore password to use",
                        "key": "passphrase",
                        "method": "io.helidon.common.pki.KeystoreKeys.Builder#passphrase(java.util.Optional<char[]>)",
                        "type": "char[]"
                    },
                    {
                        "description": "Alias of the private key in the keystore.\n\n @return alias of the key in the keystore",
                        "key": "key.alias",
                        "method": "io.helidon.common.pki.KeystoreKeys.Builder#keyAlias(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "description": "Pass-phrase of the key in the keystore (used for private keys).\n This is (by default) the same as keystore passphrase - only configure\n if it differs from keystore passphrase.\n\n @return pass-phrase of the key",
                        "key": "key.passphrase",
                        "method": "io.helidon.common.pki.KeystoreKeys.Builder#keyPassphrase(java.util.Optional<char[]>)",
                        "type": "char[]"
                    },
                    {
                        "defaultValue": "PKCS12",
                        "description": "Set type of keystore.\n Defaults to {@value #DEFAULT_KEYSTORE_TYPE},\n expected are other keystore types supported by java then can store keys under aliases.\n\n @return keystore type to load the key",
                        "key": "type",
                        "method": "io.helidon.common.pki.KeystoreKeys.Builder#type(java.lang.String)"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.common.pki.PemKeys",
                "type": "io.helidon.common.pki.PemKeys",
                "producers": [
                    "io.helidon.common.pki.PemKeys#create(io.helidon.common.config.Config)",
                    "io.helidon.common.pki.PemKeys#builder()"
                ],
                "options": [
                    {
                        "description": "Load certificate chain from PEM resource.\n\n @return resource (e.g. classpath, file path, URL etc.)",
                        "key": "cert-chain.resource",
                        "method": "io.helidon.common.pki.PemKeys.Builder#certChain(java.util.Optional<io.helidon.common.configurable.Resource>)",
                        "type": "io.helidon.common.configurable.Resource"
                    },
                    {
                        "description": "Read one or more certificates in PEM format from a resource definition. Used eg: in a trust store.\n\n @return key resource (file, classpath, URL etc.)",
                        "key": "certificates.resource",
                        "method": "io.helidon.common.pki.PemKeys.Builder#certificates(java.util.Optional<io.helidon.common.configurable.Resource>)",
                        "type": "io.helidon.common.configurable.Resource"
                    },
                    {
                        "description": "Read a private key from PEM format from a resource definition.\n\n @return key resource (file, classpath, URL etc.)",
                        "key": "key.resource",
                        "method": "io.helidon.common.pki.PemKeys.Builder#key(java.util.Optional<io.helidon.common.configurable.Resource>)",
                        "type": "io.helidon.common.configurable.Resource"
                    },
                    {
                        "description": "Read a public key from PEM format from a resource definition.\n\n @return public key resource (file, classpath, URL etc.)",
                        "key": "public-key.resource",
                        "method": "io.helidon.common.pki.PemKeys.Builder#publicKey(java.util.Optional<io.helidon.common.configurable.Resource>)",
                        "type": "io.helidon.common.configurable.Resource"
                    },
                    {
                        "description": "Passphrase for private key. If the key is encrypted (and in PEM PKCS#8 format), this passphrase will be used to\n decrypt it.\n\n @return passphrase used to encrypt the private key",
                        "key": "key.passphrase",
                        "method": "io.helidon.common.pki.PemKeys.Builder#keyPassphrase(java.util.Optional<char[]>)",
                        "type": "char[]"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.common.tls",
        "types": [
            {
                "annotatedType": "io.helidon.common.tls.TlsConfig",
                "type": "io.helidon.common.tls.Tls",
                "producers": [
                    "io.helidon.common.tls.TlsConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.common.tls.TlsConfig#builder()",
                    "io.helidon.common.tls.Tls#create(io.helidon.common.tls.TlsConfig)"
                ],
                "options": [
                    {
                        "defaultValue": "PT24H",
                        "description": "SSL session timeout.\n\n @return session timeout, defaults to {@value DEFAULT_SESSION_TIMEOUT}.",
                        "key": "session-timeout",
                        "method": "io.helidon.common.tls.TlsConfig.Builder#sessionTimeout(java.time.Duration)",
                        "type": "java.time.Duration"
                    },
                    {
                        "description": "The Tls manager. If one is not explicitly defined in the config then a default manager will be created.\n\n @return the tls manager of the tls instance\n @see ConfiguredTlsManager",
                        "key": "manager",
                        "method": "io.helidon.common.tls.TlsConfig.Builder#manager(io.helidon.common.tls.TlsManager)",
                        "providerType": "io.helidon.common.tls.spi.TlsManagerProvider",
                        "type": "io.helidon.common.tls.TlsManager",
                        "provider": true
                    },
                    {
                        "description": "Provider of the key stores used internally to create a key and trust manager factories.\n\n @return keystore provider, if not defined, provider is not specified",
                        "key": "internal-keystore-provider",
                        "method": "io.helidon.common.tls.TlsConfig.Builder#internalKeystoreProvider(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "description": "Private key to use. For server side TLS, this is required.\n For client side TLS, this is optional (used when mutual TLS is enabled).\n\n @return private key to use",
                        "key": "private-key",
                        "method": "io.helidon.common.tls.TlsConfig.Builder#privateKey(java.util.Optional<java.security.PrivateKey>)",
                        "type": "java.security.PrivateKey"
                    },
                    {
                        "defaultValue": "HTTPS",
                        "description": "Identification algorithm for SSL endpoints.\n\n @return configure endpoint identification algorithm, or set to `NONE`\n         to disable endpoint identification (equivalent to hostname verification).\n         Defaults to {@value Tls#ENDPOINT_IDENTIFICATION_HTTPS}",
                        "key": "endpoint-identification-algorithm",
                        "method": "io.helidon.common.tls.TlsConfig.Builder#endpointIdentificationAlgorithm(java.lang.String)"
                    },
                    {
                        "description": "Algorithm of the key manager factory used when private key is defined.\n Defaults to javax.net.ssl.KeyManagerFactory#getDefaultAlgorithm().\n\n @return algorithm to use",
                        "key": "key-manager-factory-algorithm",
                        "method": "io.helidon.common.tls.TlsConfig.Builder#keyManagerFactoryAlgorithm(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "description": "Provider to use when creating a new secure random.\n When defined, #secureRandomAlgorithm() must be defined as well.\n\n @return provider to use, by default no provider is specified",
                        "key": "secure-random-provider",
                        "method": "io.helidon.common.tls.TlsConfig.Builder#secureRandomProvider(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "defaultValue": "20480",
                        "description": "SSL session cache size.\n\n @return session cache size, defaults to {@value DEFAULT_SESSION_CACHE_SIZE}.",
                        "key": "session-cache-size",
                        "method": "io.helidon.common.tls.TlsConfig.Builder#sessionCacheSize(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "description": "List of certificates that form the trust manager.\n\n @return certificates to be trusted",
                        "key": "trust",
                        "kind": "LIST",
                        "method": "io.helidon.common.tls.TlsConfig.Builder#trust(java.util.List<java.security.cert.X509Certificate>)",
                        "type": "java.security.cert.X509Certificate"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Flag indicating whether Tls is enabled.\n\n @return enabled flag",
                        "key": "enabled",
                        "method": "io.helidon.common.tls.TlsConfig.Builder#enabled(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Certificate revocation check configuration.\n\n @return certificate revocation configuration",
                        "key": "revocation",
                        "method": "io.helidon.common.tls.TlsConfig.Builder#revocation(java.util.Optional<io.helidon.common.tls.RevocationConfig>)",
                        "type": "io.helidon.common.tls.RevocationConfig"
                    },
                    {
                        "description": "Use explicit provider to obtain an instance of javax.net.ssl.SSLContext.\n\n @return provider to use, defaults to none (only #protocol() is used by default)",
                        "key": "provider",
                        "method": "io.helidon.common.tls.TlsConfig.Builder#provider(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "description": "Enabled cipher suites for TLS communication.\n\n @return cipher suits to enable, by default (or if list is empty), all available cipher suites\n         are enabled",
                        "key": "cipher-suite",
                        "kind": "LIST",
                        "method": "io.helidon.common.tls.TlsConfig.Builder#enabledCipherSuites(java.util.List<java.lang.String>)"
                    },
                    {
                        "defaultValue": "NONE",
                        "description": "Configure requirement for mutual TLS.\n\n @return what type of mutual TLS to use, defaults to TlsClientAuth#NONE",
                        "key": "client-auth",
                        "method": "io.helidon.common.tls.TlsConfig.Builder#clientAuth(io.helidon.common.tls.TlsClientAuth)",
                        "type": "io.helidon.common.tls.TlsClientAuth",
                        "allowedValues": [
                            {
                                "description": "Mutual TLS is required.\n Server MUST present a certificate trusted by the client, client MUST present a certificate trusted by the server.\n This implies private key and trust configuration for both server and client.",
                                "value": "REQUIRED"
                            },
                            {
                                "description": "Mutual TLS is optional.\n Server MUST present a certificate trusted by the client, client MAY present a certificate trusted by the server.\n This implies private key configuration at least for server, trust configuration for at least client.",
                                "value": "OPTIONAL"
                            },
                            {
                                "description": "Mutual TLS is disabled.\n Server MUST present a certificate trusted by the client, client does not present a certificate.\n This implies private key configuration for server, trust configuration for client.",
                                "value": "NONE"
                            }
                        ]
                    },
                    {
                        "description": "Trust manager factory algorithm.\n\n @return algorithm to use",
                        "key": "trust-manager-factory-algorithm",
                        "method": "io.helidon.common.tls.TlsConfig.Builder#trustManagerFactoryAlgorithm(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "description": "Type of the key stores used internally to create a key and trust manager factories.\n\n @return keystore type, defaults to java.security.KeyStore#getDefaultType()",
                        "key": "internal-keystore-type",
                        "method": "io.helidon.common.tls.TlsConfig.Builder#internalKeystoreType(java.util.Optional<java.lang.String>)"
                    },
                    {
                        "defaultValue": "false",
                        "description": "Trust any certificate provided by the other side of communication.\n <p>\n <b>This is a dangerous setting: </b> if set to `true`, any certificate will be accepted, throwing away\n most of the security advantages of TLS. <b>NEVER</b> do this in production.\n\n @return whether to trust all certificates, do not use in production",
                        "key": "trust-all",
                        "method": "io.helidon.common.tls.TlsConfig.Builder#trustAll(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "TLS",
                        "description": "Configure the protocol used to obtain an instance of javax.net.ssl.SSLContext.\n\n @return protocol to use, defaults to {@value DEFAULT_PROTOCOL}",
                        "key": "protocol",
                        "method": "io.helidon.common.tls.TlsConfig.Builder#protocol(java.lang.String)"
                    },
                    {
                        "description": "Enabled protocols for TLS communication.\n Example of valid values for `TLS` protocol: `TLSv1.3`, `TLSv1.2`\n\n @return protocols to enable, by default (or if list is empty), all available protocols are enabled",
                        "key": "protocols",
                        "kind": "LIST",
                        "method": "io.helidon.common.tls.TlsConfig.Builder#enabledProtocols(java.util.List<java.lang.String>)"
                    },
                    {
                        "description": "Algorithm to use when creating a new secure random.\n\n @return algorithm to use, by default uses java.security.SecureRandom constructor",
                        "key": "secure-random-algorithm",
                        "method": "io.helidon.common.tls.TlsConfig.Builder#secureRandomAlgorithm(java.util.Optional<java.lang.String>)"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.common.tls.RevocationConfig",
                "type": "io.helidon.common.tls.RevocationConfig",
                "producers": [
                    "io.helidon.common.tls.RevocationConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.common.tls.RevocationConfig#builder()"
                ],
                "options": [
                    {
                        "defaultValue": "false",
                        "description": "Allow revocation check to succeed if the revocation status cannot be\n determined for one of the following reasons:\n <ul>\n  <li>The CRL or OCSP response cannot be obtained because of a\n      network error.\n  <li>The OCSP responder returns one of the following errors\n      specified in section 2.3 of RFC 2560: internalError or tryLater.\n </ul>\n\n @return whether soft fail is enabled",
                        "key": "soft-fail-enabled",
                        "method": "io.helidon.common.tls.RevocationConfig.Builder#softFailEnabled(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "The URI that identifies the location of the OCSP responder. This\n overrides the `ocsp.responderURL` security property and any\n responder specified in a certificate's Authority Information Access\n Extension, as defined in RFC 5280.\n\n @return OCSP responder URI",
                        "key": "ocsp-responder-uri",
                        "method": "io.helidon.common.tls.RevocationConfig.Builder#ocspResponderUri(java.util.Optional<java.net.URI>)",
                        "type": "java.net.URI"
                    },
                    {
                        "defaultValue": "false",
                        "description": "Prefer CRL over OCSP.\n Default value is `false`. OCSP is preferred over the CRL by default.\n\n @return whether to prefer CRL over OCSP",
                        "key": "prefer-crl-over-ocsp",
                        "method": "io.helidon.common.tls.RevocationConfig.Builder#preferCrlOverOcsp(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "false",
                        "description": "Only check the revocation status of end-entity certificates.\n Default value is `false`.\n\n @return whether to check only end-entity certificates",
                        "key": "check-only-end-entity",
                        "method": "io.helidon.common.tls.RevocationConfig.Builder#checkOnlyEndEntity(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Enable fallback to the less preferred checking option.\n <br>\n If the primary method for revocation checking fails to verify the revocation status of a certificate\n (such as using a CRL or OCSP), the checker will attempt alternative methods. This option ensures\n whether revocation checking is performed strictly according to the specified method, or should fallback\n to the one less preferred. OCSP is preferred over the CRL by default.\n\n @return whether to allow fallback to the less preferred checking option",
                        "key": "fallback-enabled",
                        "method": "io.helidon.common.tls.RevocationConfig.Builder#fallbackEnabled(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "false",
                        "description": "Flag indicating whether this revocation config is enabled.\n\n @return enabled flag",
                        "key": "enabled",
                        "method": "io.helidon.common.tls.RevocationConfig.Builder#enabled(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.common.socket",
        "types": [
            {
                "annotatedType": "io.helidon.common.socket.SocketOptions",
                "type": "io.helidon.common.socket.SocketOptions",
                "producers": [
                    "io.helidon.common.socket.SocketOptions#create(io.helidon.common.config.Config)",
                    "io.helidon.common.socket.SocketOptions#builder()"
                ],
                "options": [
                    {
                        "defaultValue": "PT30S",
                        "description": "Socket read timeout. Default is 30 seconds.\n\n @return read timeout duration",
                        "key": "read-timeout",
                        "method": "io.helidon.common.socket.SocketOptions.Builder#readTimeout(java.time.Duration)",
                        "type": "java.time.Duration"
                    },
                    {
                        "description": "Socket send buffer size.\n\n @return buffer size, in bytes\n @see java.net.StandardSocketOptions#SO_SNDBUF",
                        "key": "socket-send-buffer-size",
                        "method": "io.helidon.common.socket.SocketOptions.Builder#socketSendBufferSize(java.util.Optional<java.lang.Integer>)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Socket reuse address.\n Default is `true`.\n\n @return whether to reuse address\n @see java.net.StandardSocketOptions#SO_REUSEADDR",
                        "key": "socket-reuse-address",
                        "method": "io.helidon.common.socket.SocketOptions.Builder#socketReuseAddress(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "PT10S",
                        "description": "Socket connect timeout. Default is 10 seconds.\n\n @return connect timeout duration",
                        "key": "connect-timeout",
                        "method": "io.helidon.common.socket.SocketOptions.Builder#connectTimeout(java.time.Duration)",
                        "type": "java.time.Duration"
                    },
                    {
                        "defaultValue": "false",
                        "description": "This option may improve performance on some systems.\n Default is `false`.\n\n @return whether to use TCP_NODELAY, defaults to `false`\n @see java.net.StandardSocketOptions#TCP_NODELAY",
                        "key": "tcp-no-delay",
                        "method": "io.helidon.common.socket.SocketOptions.Builder#tcpNoDelay(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Socket receive buffer size.\n\n @return buffer size, in bytes\n @see java.net.StandardSocketOptions#SO_RCVBUF",
                        "key": "socket-receive-buffer-size",
                        "method": "io.helidon.common.socket.SocketOptions.Builder#socketReceiveBufferSize(java.util.Optional<java.lang.Integer>)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Configure socket keep alive.\n Default is `true`.\n\n @return keep alive\n @see java.net.StandardSocketOptions#SO_KEEPALIVE",
                        "key": "socket-keep-alive",
                        "method": "io.helidon.common.socket.SocketOptions.Builder#socketKeepAlive(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.http.encoding",
        "types": [
            {
                "annotatedType": "io.helidon.http.encoding.ContentEncodingContextConfig",
                "type": "io.helidon.http.encoding.ContentEncodingContext",
                "producers": [
                    "io.helidon.http.encoding.ContentEncodingContextConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.http.encoding.ContentEncodingContextConfig#builder()",
                    "io.helidon.http.encoding.ContentEncodingContext#create(io.helidon.http.encoding.ContentEncodingContextConfig)"
                ],
                "options": [
                    {
                        "description": "List of content encodings that should be used.\n Encodings configured here have priority over encodings discovered through service loader.\n\n @return list of content encodings to be used (such as `gzip,deflate`)",
                        "key": "content-encodings",
                        "kind": "LIST",
                        "method": "io.helidon.http.encoding.ContentEncodingContextConfig.Builder#contentEncodings(java.util.List<io.helidon.http.encoding.ContentEncoding>)",
                        "providerType": "io.helidon.http.encoding.spi.ContentEncodingProvider",
                        "type": "io.helidon.http.encoding.ContentEncoding",
                        "provider": true
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.http",
        "types": [
            {
                "annotatedType": "io.helidon.http.RequestedUriDiscoveryContext.Builder",
                "type": "io.helidon.http.RequestedUriDiscoveryContext",
                "producers": [
                    "io.helidon.http.RequestedUriDiscoveryContext.Builder#build()",
                    "io.helidon.http.RequestedUriDiscoveryContext#create(io.helidon.common.config.Config)"
                ],
                "options": [
                    {
                        "description": "Sets the discovery types for requested URI discovery for requests arriving on the socket.",
                        "key": "types",
                        "kind": "LIST",
                        "method": "io.helidon.http.RequestedUriDiscoveryContext.Builder#types(java.util.List<io.helidon.http.RequestedUriDiscoveryContext.RequestedUriDiscoveryType>)",
                        "type": "io.helidon.http.RequestedUriDiscoveryContext.RequestedUriDiscoveryType",
                        "allowedValues": [
                            {
                                "description": "The `io.helidon.http.Header#FORWARDED` header is used to discover the original requested URI.",
                                "value": "FORWARDED"
                            },
                            {
                                "description": "The\n `io.helidon.http.Header#X_FORWARDED_PROTO`,\n `io.helidon.http.Header#X_FORWARDED_HOST`,\n `io.helidon.http.Header#X_FORWARDED_PORT`,\n `io.helidon.http.Header#X_FORWARDED_PREFIX`\n headers are used to discover the original requested URI.",
                                "value": "X_FORWARDED"
                            },
                            {
                                "description": "This is the default, only the `io.helidon.http.Header#HOST` header is used to discover\n requested URI.",
                                "value": "HOST"
                            }
                        ]
                    },
                    {
                        "description": "Sets the trusted proxies for requested URI discovery for requests arriving on the socket.",
                        "key": "trusted-proxies",
                        "method": "io.helidon.http.RequestedUriDiscoveryContext.Builder#trustedProxies(io.helidon.common.configurable.AllowList)",
                        "type": "io.helidon.common.configurable.AllowList"
                    },
                    {
                        "defaultValue": "true if 'types' or 'trusted-proxies' is set; false otherwise",
                        "description": "Sets whether requested URI discovery is enabled for requestes arriving on the socket.",
                        "key": "enabled",
                        "method": "io.helidon.http.RequestedUriDiscoveryContext.Builder#enabled(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.http.media",
        "types": [
            {
                "annotatedType": "io.helidon.http.media.MediaContextConfig",
                "type": "io.helidon.http.media.MediaContext",
                "producers": [
                    "io.helidon.http.media.MediaContextConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.http.media.MediaContextConfig#builder()",
                    "io.helidon.http.media.MediaContext#create(io.helidon.http.media.MediaContextConfig)"
                ],
                "options": [
                    {
                        "defaultValue": "true",
                        "description": "Should we register defaults of Helidon, such as String media support.\n\n @return whether to register default media supports",
                        "key": "register-defaults",
                        "method": "io.helidon.http.media.MediaContextConfig.Builder#registerDefaults(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "description": "Media supports to use.\n This instance has priority over provider(s) discovered by service loader.\n The providers are used in order of calling this method, where the first support added is the\n first one to be queried for readers and writers.\n\n @return media supports",
                        "key": "media-supports",
                        "kind": "LIST",
                        "method": "io.helidon.http.media.MediaContextConfig.Builder#mediaSupports(java.util.List<io.helidon.http.media.MediaSupport>)",
                        "providerType": "io.helidon.http.media.spi.MediaSupportProvider",
                        "type": "io.helidon.http.media.MediaSupport",
                        "provider": true
                    },
                    {
                        "description": "Existing context to be used as a fallback for this context.\n\n @return media context to use if supports configured on this request cannot provide a good result",
                        "key": "fallback",
                        "method": "io.helidon.http.media.MediaContextConfig.Builder#fallback(java.util.Optional<io.helidon.http.media.MediaContext>)",
                        "type": "io.helidon.http.media.MediaContext"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.faulttolerance",
        "types": [
            {
                "annotatedType": "io.helidon.faulttolerance.CircuitBreakerConfig",
                "prefix": "fault-tolerance.circuit-breakers",
                "type": "io.helidon.faulttolerance.CircuitBreaker",
                "standalone": true,
                "producers": [
                    "io.helidon.faulttolerance.CircuitBreakerConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.faulttolerance.CircuitBreakerConfig#builder()",
                    "io.helidon.faulttolerance.CircuitBreaker#create(io.helidon.faulttolerance.CircuitBreakerConfig)"
                ],
                "options": [
                    {
                        "defaultValue": "PT5S",
                        "description": "How long to wait before transitioning from open to half-open state.\n\n @return delay",
                        "key": "delay",
                        "method": "io.helidon.faulttolerance.CircuitBreakerConfig.Builder#delay(java.time.Duration)",
                        "type": "java.time.Duration"
                    },
                    {
                        "defaultValue": "10",
                        "description": "Rolling window size used to calculate ratio of failed requests.\n Default is {@value #DEFAULT_VOLUME}.\n\n @return how big a window is used to calculate error errorRatio\n @see #errorRatio()",
                        "key": "volume",
                        "method": "io.helidon.faulttolerance.CircuitBreakerConfig.Builder#volume(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "60",
                        "description": "How many failures out of 100 will trigger the circuit to open.\n This is adapted to the #volume() used to handle the window of requests.\n <p>If errorRatio is 40, and volume is 10, 4 failed requests will open the circuit.\n Default is {@value #DEFAULT_ERROR_RATIO}.\n\n @return percent of failure that trigger the circuit to open\n @see #volume()",
                        "key": "error-ratio",
                        "method": "io.helidon.faulttolerance.CircuitBreakerConfig.Builder#errorRatio(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "1",
                        "description": "How many successful calls will close a half-open circuit.\n Nevertheless, the first failed call will open the circuit again.\n Default is {@value #DEFAULT_SUCCESS_THRESHOLD}.\n\n @return number of calls",
                        "key": "success-threshold",
                        "method": "io.helidon.faulttolerance.CircuitBreakerConfig.Builder#successThreshold(int)",
                        "type": "java.lang.Integer"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.faulttolerance.AsyncConfig",
                "type": "io.helidon.faulttolerance.Async",
                "producers": [
                    "io.helidon.faulttolerance.AsyncConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.faulttolerance.AsyncConfig#builder()",
                    "io.helidon.faulttolerance.Async#create(io.helidon.faulttolerance.AsyncConfig)"
                ],
                "options": [
                    {
                        "description": "Name of an executor service. This is only honored when service registry is used.\n\n @return name fo the java.util.concurrent.ExecutorService to lookup\n @see #executor()",
                        "key": "executor-name",
                        "method": "io.helidon.faulttolerance.AsyncConfig.Builder#executorName(java.util.Optional<java.lang.String>)"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.faulttolerance.BulkheadConfig",
                "prefix": "fault-tolerance.bulkheads",
                "type": "io.helidon.faulttolerance.Bulkhead",
                "standalone": true,
                "producers": [
                    "io.helidon.faulttolerance.BulkheadConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.faulttolerance.BulkheadConfig#builder()",
                    "io.helidon.faulttolerance.Bulkhead#create(io.helidon.faulttolerance.BulkheadConfig)"
                ],
                "options": [
                    {
                        "defaultValue": "10",
                        "description": "Maximal number of parallel requests going through this bulkhead.\n When the limit is reached, additional requests are enqueued.\n\n @return maximal number of parallel calls, defaults is {@value DEFAULT_LIMIT}",
                        "key": "limit",
                        "method": "io.helidon.faulttolerance.BulkheadConfig.Builder#limit(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "10",
                        "description": "Maximal number of enqueued requests waiting for processing.\n When the limit is reached, additional attempts to invoke\n a request will receive a BulkheadException.\n\n @return length of the queue",
                        "key": "queue-length",
                        "method": "io.helidon.faulttolerance.BulkheadConfig.Builder#queueLength(int)",
                        "type": "java.lang.Integer"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.faulttolerance.TimeoutConfig",
                "prefix": "fault-tolerance.timeouts",
                "type": "io.helidon.faulttolerance.Timeout",
                "standalone": true,
                "producers": [
                    "io.helidon.faulttolerance.TimeoutConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.faulttolerance.TimeoutConfig#builder()",
                    "io.helidon.faulttolerance.Timeout#create(io.helidon.faulttolerance.TimeoutConfig)"
                ],
                "options": [
                    {
                        "defaultValue": "false",
                        "description": "Flag to indicate that code must be executed in current thread instead\n of in an executor's thread. This flag is `false` by default.\n\n @return  whether to execute on current thread (`true`), or in an executor service (`false`})",
                        "key": "current-thread",
                        "method": "io.helidon.faulttolerance.TimeoutConfig.Builder#currentThread(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "PT10S",
                        "description": "Duration to wait before timing out.\n Defaults to `10 seconds`.\n\n @return timeout",
                        "key": "timeout",
                        "method": "io.helidon.faulttolerance.TimeoutConfig.Builder#timeout(java.time.Duration)",
                        "type": "java.time.Duration"
                    }
                ]
            },
            {
                "annotatedType": "io.helidon.faulttolerance.RetryConfig",
                "prefix": "fault-tolerance.retries",
                "type": "io.helidon.faulttolerance.Retry",
                "standalone": true,
                "producers": [
                    "io.helidon.faulttolerance.RetryConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.faulttolerance.RetryConfig#builder()",
                    "io.helidon.faulttolerance.Retry#create(io.helidon.faulttolerance.RetryConfig)"
                ],
                "options": [
                    {
                        "defaultValue": "PT1S",
                        "description": "Overall timeout of all retries combined.\n\n @return overall timeout",
                        "key": "overall-timeout",
                        "method": "io.helidon.faulttolerance.RetryConfig.Builder#overallTimeout(java.time.Duration)",
                        "type": "java.time.Duration"
                    },
                    {
                        "defaultValue": "PT0.2S",
                        "description": "Base delay between try and retry.\n Defaults to `200 ms`.\n\n @return delay between retries (combines with retry policy)",
                        "key": "delay",
                        "method": "io.helidon.faulttolerance.RetryConfig.Builder#delay(java.time.Duration)",
                        "type": "java.time.Duration"
                    },
                    {
                        "defaultValue": "3",
                        "description": "Number of calls (first try + retries).\n\n @return number of desired calls, must be 1 (means no retries) or higher.",
                        "key": "calls",
                        "method": "io.helidon.faulttolerance.RetryConfig.Builder#calls(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "defaultValue": "PT-1S",
                        "description": "Jitter for Retry.JitterRetryPolicy. If unspecified (value of `-1`),\n delaying retry policy is used. If both this value, and #delayFactor() are specified, delaying retry policy\n would be used.\n\n @return jitter",
                        "key": "jitter",
                        "method": "io.helidon.faulttolerance.RetryConfig.Builder#jitter(java.time.Duration)",
                        "type": "java.time.Duration"
                    },
                    {
                        "defaultValue": "-1.0",
                        "description": "Delay retry policy factor. If unspecified (value of `-1`), Jitter retry policy would be used, unless\n jitter is also unspecified.\n <p>\n Default when Retry.DelayingRetryPolicy is used is `2`.\n\n @return delay factor for delaying retry policy",
                        "key": "delay-factor",
                        "method": "io.helidon.faulttolerance.RetryConfig.Builder#delayFactor(double)",
                        "type": "java.lang.Double"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.cors",
        "types": [
            {
                "annotatedType": "io.helidon.cors.CrossOriginConfig.Builder",
                "type": "io.helidon.cors.CrossOriginConfig",
                "producers": [
                    "io.helidon.cors.CrossOriginConfig.Builder#build()",
                    "io.helidon.cors.CrossOriginConfig#create(io.helidon.common.config.Config)"
                ],
                "options": [
                    {
                        "defaultValue": "{+}",
                        "description": "Updates the path prefix for this cross-origin config.",
                        "key": "path-pattern",
                        "method": "io.helidon.cors.CrossOriginConfig.Builder#pathPattern(java.lang.String)"
                    },
                    {
                        "defaultValue": "*",
                        "description": "Sets the allow headers.",
                        "key": "allow-headers",
                        "kind": "LIST",
                        "method": "io.helidon.cors.CrossOriginConfig.Builder#allowHeaders(java.lang.String[])"
                    },
                    {
                        "defaultValue": "3600",
                        "description": "Sets the maximum age.",
                        "key": "max-age-seconds",
                        "method": "io.helidon.cors.CrossOriginConfig.Builder#maxAgeSeconds(long)",
                        "type": "java.lang.Long"
                    },
                    {
                        "defaultValue": "false",
                        "description": "Sets the allow credentials flag.",
                        "key": "allow-credentials",
                        "method": "io.helidon.cors.CrossOriginConfig.Builder#allowCredentials(boolean)",
                        "type": "java.lang.Boolean"
                    },
                    {
                        "defaultValue": "*",
                        "description": "Sets the allowOrigins.",
                        "key": "allow-origins",
                        "kind": "LIST",
                        "method": "io.helidon.cors.CrossOriginConfig.Builder#allowOrigins(java.lang.String[])"
                    },
                    {
                        "description": "Sets the expose headers.",
                        "key": "expose-headers",
                        "kind": "LIST",
                        "method": "io.helidon.cors.CrossOriginConfig.Builder#exposeHeaders(java.lang.String[])"
                    },
                    {
                        "defaultValue": "*",
                        "description": "Sets the allow methods.",
                        "key": "allow-methods",
                        "kind": "LIST",
                        "method": "io.helidon.cors.CrossOriginConfig.Builder#allowMethods(java.lang.String[])"
                    },
                    {
                        "defaultValue": "true",
                        "description": "Sets whether this config should be enabled or not.",
                        "key": "enabled",
                        "method": "io.helidon.cors.CrossOriginConfig.Builder#enabled(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.microprofile.server",
        "types": [
            {
                "annotatedType": "io.helidon.microprofile.server.Server.Builder",
                "description": "Configuration of Helidon Microprofile Server",
                "prefix": "server",
                "type": "io.helidon.microprofile.server.Server",
                "standalone": true,
                "producers": [
                    "io.helidon.microprofile.server.Server.Builder#build()"
                ],
                "options": [
                    {
                        "description": "Configure listen port.",
                        "key": "port",
                        "method": "io.helidon.microprofile.server.Server.Builder#port(int)",
                        "type": "java.lang.Integer"
                    },
                    {
                        "description": "Configure listen host.",
                        "key": "host",
                        "method": "io.helidon.microprofile.server.Server.Builder#host(java.lang.String)"
                    }
                ]
            }
        ]
    }
]
[
    {
        "module": "io.helidon.microprofile.openapi",
        "types": [
            {
                "annotatedType": "io.helidon.microprofile.openapi.MpOpenApiManagerConfig",
                "type": "io.helidon.microprofile.openapi.MpOpenApiManagerConfig",
                "producers": [
                    "io.helidon.microprofile.openapi.MpOpenApiManagerConfig#create(io.helidon.common.config.Config)",
                    "io.helidon.microprofile.openapi.MpOpenApiManagerConfig#builder()"
                ],
                "options": [
                    {
                        "description": "If `true` and the `jakarta.ws.rs.core.Application` class returns a non-empty set, endpoints defined by\n other resources are not included in the OpenAPI document.\n\n @return `true` if enabled, `false` otherwise",
                        "key": "mp.openapi.extensions.helidon.use-jaxrs-semantics",
                        "method": "io.helidon.microprofile.openapi.MpOpenApiManagerConfig.Builder#useJaxRsSemantics(boolean)",
                        "type": "java.lang.Boolean"
                    }
                ]
            }
        ]
    }
]