}

    }

    /**
     * Processes a document through the ingest pipeline.
     * Applies all available ingesters to transform the document data.
     *
     * @param paramMap the data store parameters
     * @param dataMap the document data to process
     * @return the processed document data
     */

 *
 * @param <REQ> The type of the request
 * @param <REP> The type of the response, which must extend {@code Result<REQ>}
 * @param request The original request that was processed
 * @param result The result of the request, if successful; may be null if an error occurred
 * @param error Any error that occurred during processing; null if the request was successful
 * @since 4.0.0
 */
@Experimental

 */
package org.codelibs.fess.crawler.processor;

import org.codelibs.fess.crawler.entity.ResponseData;

/**
 * The ResponseProcessor interface defines a contract for processing response data.
 * Implementations of this interface are responsible for handling the response data
 * obtained during a crawling process.
 */
public interface ResponseProcessor {

    /**
     * Processes the given response data.
     *

        return url;
    }

    /**
     * Extracts and processes the site path from a URL with proper encoding handling.
     * Removes protocol, query parameters, and applies URL decoding based on encoding settings.
     *
     * @param u the URL string to process
     * @param encoding the character encoding to use for URL decoding
     * @return the processed site path, abbreviated if necessary
     */

                    java.util.function.BiFunction<org.opensearch.action.update.UpdateRequestBuilder, org.opensearch.search.SearchHit, org.opensearch.action.update.UpdateRequestBuilder> processor) {
                // Return 0 to simulate no documents processed due to error
                return 0L;
            }
        };
        ComponentUtil.register(errorClient, "searchEngineClient");

        }

        /**
         * Sets whether plugins should be processed during project building.
         * When true, the builder will process plugin information which may include
         * resolving plugin dependencies and executing plugin goals that participate in project building.
         *
         * @param processPlugins true if plugins should be processed, false otherwise
         * @return this builder instance
         */

        default -> false;
        };
    }

    /**
     * Processes and saves an image from the input stream to the output file as a thumbnail.
     *
     * <p>This method reads image data, validates dimensions, applies subsampling and scaling
     * transformations based on configuration settings, and writes the processed thumbnail
     * to the specified output file.</p>
     *

    /**
     * Set of fully qualified class names that have been processed and contain the {@link Named} annotation.
     */
    private final Set<String> processedClasses = new HashSet<>();

    /**
     * Processes classes with the {@link Named} annotation and generates an index file.
     *
     * @param annotations the annotation types requested to be processed

      sink.flush()
    }
  }

  /**
   * Tell the peer to stop creating streams and that we last processed `lastGoodStreamId`, or zero
   * if no streams were processed.
   *
   * @param lastGoodStreamId the last stream ID processed, or zero if no streams were processed.
   * @param errorCode reason for closing the connection.
   * @param debugData only valid for HTTP/2; opaque debug data to send.
   */

A "middleware" is a function that works with every **request** before it is processed by any specific *path operation*. And also with every **response** before returning it.

* It takes each **request** that comes to your application.
* It can then do something to that **request** or run any needed code.
* Then it passes the **request** to be processed by the rest of the application (by some *path operation*).