*/
    public SearchForm() {
    }

    /**
     * The name field for searching web configurations.
     */
    public String name;

    /**
     * The URLs field for searching web configurations.
     */
    public String urls;

    /**
     * The description field for searching web configurations.
     */
    public String description;

     * Adds a client with a regular expression pattern.
     * @param regex The regular expression to match URLs.
     * @param client The CrawlerClient instance.
     */
    public void addClient(final String regex, final CrawlerClient client) {
        if (StringUtil.isBlank(regex)) {
            throw new CrawlerSystemException(
                    "URL pattern regular expression is null or blank. Cannot register client without a valid pattern.");
        }

labels.excludedUrls=Excluded URLs for Crawling
labels.excludedDocPaths=Excluded Paths for Searching
labels.excludedDocUrls=Excluded URLs for Searching
labels.hostname=Hostname
labels.id=ID
labels.includedPaths=Included Paths for Crawling
labels.includedUrls=Included URLs for Crawling
labels.includedDocPaths=Included Paths for Searching
labels.includedDocUrls=Included URLs for Searching
labels.maxAccessCount=Max Access Count

    /**
     * Default constructor.
     */
    public SearchBody() {
        super();
    }

    /** Name of the web crawling configuration */
    public String name;

    /** URLs to crawl */
    public String urls;

    /** Description of the web crawling configuration */
    public String description;

   */
  @get:JvmName("fragment") val fragment: String?,
  /** Canonical URL. */
  private val url: String,
) {
  val isHttps: Boolean
    get() = scheme == "https"

  /** Returns this URL as a [java.net.URL][URL]. */
  @JvmName("url")
  fun toUrl(): URL {
    try {
      return URL(url)
    } catch (e: MalformedURLException) {
      throw RuntimeException(e) // Unexpected!
    }

        @ParameterizedTest
        @DisplayName("Should reject invalid binding URLs")
        @ValueSource(strings = { "invalid_url", "proto:", "proto:server[]", "proto:[key=]", "proto:[=value]", "proto:server[endpoint=]",
                "proto:[endpoint=]" })
        void testParseInvalidBindingUrls(String url) {
            // When/Then: Should throw DcerpcException for invalid URLs

    }

    /**
     * Parses and filters URL patterns from text based on protocol types.
     * Processes each line of the input text, filtering URLs based on web and file protocol support.
     *
     * @param text the raw text containing URL patterns, one per line
     * @param web true if web protocol URLs should be included
     * @param file true if file protocol URLs should be included

            }
        }
        return result;
    }

    /**
     * Replaces URL for display or URL converter.
     *
     * @param url the URL to replace
     * @return the replaced URL
     */
    public String replaceUrl(final String url) { // for display or url converer
        if (cachedPathMappingList == null) {
            synchronized (this) {

                    crawler.addUrl(u);
                    if (logger.isInfoEnabled()) {
                        logger.info("Target URL: {}", u);
                    }
                }
            }));

            // set included urls
            final AtomicBoolean urlEncodeDisabled = new AtomicBoolean(false);

        Set<String> packages = new LinkedHashSet<>();

        try {
            Enumeration<URL> urls = loader.getResources(BUILDER.getExtensionDescriptorLocation());
            while (urls.hasMoreElements()) {

                try (InputStream is = urls.nextElement().openStream()) {
                    ExtensionDescriptor descriptor = BUILDER.build(is);