return processResponse(searchResponseOpt);
    }

    /**
     * Processes the OpenSearch response and converts it to a SearchResult.
     *
     * @param searchResponseOpt the optional search response from OpenSearch
     * @return the processed search result
     */
    protected SearchResult processResponse(final OptionalEntity<SearchResponse> searchResponseOpt) {

         * @param query the query string to process
         * @param chain the next filter chain to invoke
         * @return the processed Query object
         */
        Query parse(final String query, final FilterChain chain);
    }

    /**
     * Interface for the filter chain that processes queries.
     * Each filter in the chain can invoke the next filter or terminate the chain.
     */
    public interface FilterChain {

        }
        return roleSet;
    }

    /**
     * Processes the access token.
     * @param request The HTTP request.
     * @param roleSet The set of roles.
     * @param isApiRequest Whether the request is an API request.
     * @return true if the access token is processed, false otherwise.
     */

        try {
            // Start multiple processes
            processHelper.startProcess(sessionId1, cmdList, pbCall);
            processHelper.startProcess(sessionId2, cmdList, pbCall);

            assertTrue(processHelper.isProcessRunning());

            // Wait a bit for the processes to start
            Thread.sleep(50);

            // Destroy all processes
            processHelper.destroy();

        /** Indicates that a URL was prepared for crawling. */
        PREPARED,
        /** Indicates that a URL redirect was encountered. */
        REDIRECTED,
        /** Indicates that a URL was processed completely. */
        PROCESSED
    }

                    indexUpdateCallback.store(paramMap, dataMap);
                    crawlerStatsHelper.record(keyObj, StatsAction.PROCESSED);
                } else {
                    logger.warn("Unexpected response processor: expected=DefaultResponseProcessor, actual={}, url={}",
                            responseProcessor.getClass().getSimpleName(), url);

     * @param crawlingInfoId the crawling session ID
     * @param url the URL to process
     * @return a map containing the processed document data
     * @throws CrawlingAccessException if crawling fails or configuration is invalid
     * @throws ChildUrlsException if the URL redirects to another location
     * @throws CrawlerSystemException if data deserialization fails
     */

        }
        if (bulkRequestBuilder.numberOfActions() > requestCacheSize) {
            flush();
        }
        return (long) ids.length;
    };

    /**
     * Processes the score boosting.
     * @return The number of processed documents.
     */
    public abstract long process();

    /**
     * Enables this score booster.
     */
    protected void enable() {

        Object result1 = scriptExecutor.execute("testengine", "script1");
        assertEquals("processed: script1", result1);

        Object result2 = scriptExecutor.execute("TESTENGINE", "script2");
        assertEquals("processed: script2", result2);

        Object result3 = scriptExecutor.execute("TestEngine", "script3");
        assertEquals("processed: script3", result3);
    }

    @Test

        assertNotNull(queryBuilder);
        assertTrue(queryBuilder instanceof WildcardQueryBuilder);

        // Query was processed successfully

        // Query was processed successfully
        WildcardQueryBuilder wqb = (WildcardQueryBuilder) queryBuilder;
        assertEquals("title", wqb.fieldName());
    }

    @Test