```bash
  curl -u admin:admin ...
  # or
  curl -H "Authorization: Basic YWRtaW46YWRtaW4=" ...
  ```

#### Issue: Large bulk imports timing out

**Solution**:
- Split large files into smaller batches (e.g., 10,000 docs per file)
- Increase timeout in `system.properties`:
  ```properties
  crawler.document.request.timeout=600000
  ```
- Use asynchronous import via Admin UI instead of API

        assertTrue(pattern.matcher("application/x-lha").matches());
        assertTrue(pattern.matcher("application/x-lha-compressed").matches());
    }

    @Test
    public void test_fsFileRulePattern_xmlTypes() {
        Pattern pattern = Pattern.compile(FS_FILE_RULE_PATTERN);
        assertTrue(pattern.matcher("application/xml").matches());

                if (excludedPaths != null && excludedPaths.matcher(path).matches()) {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Path {} matches the include/exclude path expression {} on {} of label.", path, excludedPaths, value);
                    }
                    return false;
                }
                if (logger.isDebugEnabled()) {

            final Matcher matcher = pattern.matcher(v.trim());
            if (matcher.matches()) {
                final PrunedTag tag = new PrunedTag(matcher.group(1));
                if (matcher.group(2) != null) {
                    final String attrPair = matcher.group(2).substring(1, matcher.group(2).length() - 1);

        inline fun <reified T> inAnyOrder(items: List<T>): Matcher<Iterable<T>> = inAnyOrder(items.toTypedArray())

        /**
         * Matcher checking each item is present exactly once in a given iterable, but an any position,
         * and that there are no unexpected items.
         */
        private
        fun <T> inAnyOrder(items: Array<out T>): Matcher<Iterable<T>> = Matchers.containsInAnyOrder(*items)

    }

    /**
     * Creates a path matcher function for path mapping.
     *
     * @param matcher the regex matcher
     * @param replacement the replacement string
     * @return the path matcher function
     */
    public BiFunction<String, Matcher, String> createPathMatcher(final Matcher matcher, final String replacement) { // for PathMapping

            throw new IllegalStateException("Malformed distributionUrl line: " + distributionUrl);
        }
        String url = distributionUrl.substring(idx + 1).trim();

        Matcher m = WRAPPER_VERSION_EXTRACT.matcher(url);
        if (!m.matches()) {
            throw new IllegalStateException("Could not extract wrapper version from distributionUrl: " + url);
        }
        return m.group(1);
    }

        final String servletPath = request.getServletPath();
        final boolean matches = servletPath.startsWith(CHAT_API_PATH);
        if (logger.isTraceEnabled()) {
            logger.trace("ChatApiManager.matches() checking path. servletPath={}, expectedPrefix={}, matches={}", servletPath,
                    CHAT_API_PATH, matches);
        }
        return matches;
    }

    @Override

    }

    private static boolean isOldMethod(JApiMethod jApiMethod, Map<AccessorKey, ReplacedAccessor> upgradedMethods, Pattern pattern) {
        String name = jApiMethod.getName();
        if (!pattern.matcher(name).matches()) {
            return false;
        }
        return upgradedMethods.containsKey(AccessorKey.ofOldMethod(jApiMethod));
    }

                    .findFirst()
                    .orElseThrow(() -> new IOException("Can't find package definition in file " + file));
                Matcher matcher = pattern.matcher(packageLine);
                if (matcher.find()) {
                    return matcher.group(1);
                } else {
                    throw new IOException("Can't extract package name from file " + file);
                }
            }