Vous verrez quelque chose comme :

```JSON
{"item_id": 5, "q": "somequery"}
```

## Documentation interactive de l'API

 *   }
 * }.visit(type);
 * }
 *
 * <p>One {@code Type} is visited at most once. The second time the same type is visited, it's
 * ignored by {@link #visit}. This avoids infinite recursion caused by recursive type bounds.
 *
 * <p>This class is not thread safe.
 *
 * @author Ben Yu
 */
abstract class TypeVisitor {

  private final Set<Type> visited = new HashSet<>();

  /**

            return g;
        }

        List<MetadataGraphVertex> visited = new ArrayList<>(g.getVertices().size());
        visit(g.getEntry(), visited, g);

        List<MetadataGraphVertex> dropList = new ArrayList<>(g.getVertices().size());

        // collect drop list
        for (MetadataGraphVertex v : g.getVertices()) {
            if (!visited.contains(v)) {
                dropList.add(v);
            }
        }

        return sortedNodes;
    }

    // Helper method to visit a node
    private static void visitNode(BuildStep node, Set<BuildStep> visited, List<BuildStep> sortedNodes) {
        if (visited.add(node)) {
            // For each successor of the current node, visit unvisited successors
            node.successors.forEach(successor -> visitNode(successor, visited, sortedNodes));
            sortedNodes.add(node);
        }
    }

     */
    protected void extractFrontMatterMetadata(final Node document, final ExtractData extractData) {
        final YamlFrontMatterVisitor visitor = new YamlFrontMatterVisitor();
        document.accept(visitor);

        final Map<String, List<String>> frontMatter = visitor.getData();
        for (final Map.Entry<String, List<String>> entry : frontMatter.entrySet()) {
            final String key = "frontmatter." + entry.getKey();

        ClasspathContainer cpc;

        List<MetadataGraphVertex> visited;

        // -----------------------------------------------------------------------
        protected ClasspathGraphVisitor(MetadataGraph cleanGraph, ClasspathContainer cpc) {
            this.cpc = cpc;
            this.graph = cleanGraph;

            visited = new ArrayList<>(cleanGraph.getVertices().size());
        }

    /**
     * Traverses this node and potentially its children using the specified visitor.
     *
     * @param visitor the visitor to call back, must not be {@code null}
     * @return {@code true} to visit siblings nodes of this node as well, {@code false} to skip siblings
     */
    boolean accept(@Nonnull NodeVisitor visitor);

    /**
     * Returns a new tree starting at this node, filtering the children.

        return queryBuilder.rewrite(queryShardContext);
    }

    @Override
    public void visit(final QueryBuilderVisitor visitor) {
        queryBuilder.visit(visitor);
    }

    @Override
    public XContentBuilder toXContent(final XContentBuilder builder, final Params params) throws IOException {

        accessResult.setUrl("https://example.com/visited");
        accessResultMap.put("https://example.com/visited", accessResult);

        UrlQueueImpl<Long> newUrl = new UrlQueueImpl<>();
        newUrl.setSessionId(sessionId);
        newUrl.setUrl("https://example.com/new");

        UrlQueueImpl<Long> visited = new UrlQueueImpl<>();
        visited.setSessionId(sessionId);
        visited.setUrl("https://example.com/visited");

    private void nonEmptyPredecessors(BuildStep step, Set<BuildStep> preds, Set<BuildStep> visited) {
        if (visited.add(step)) {
            step.predecessors.forEach(ch -> {
                if (ch.executions().findAny().isPresent()) {
                    preds.add(ch);
                } else {
                    nonEmptyPredecessors(ch, preds, visited);
                }
            });
        }
    }