Thread th = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException ignore) {}
            deferred.resolve(new SuggestResponse("", 0, Collections.emptyList(), 0, null));
        });
        th.start();

        final CountDownLatch latch = new CountDownLatch(1);
        deferred.promise().then(response -> latch.countDown());

     * The host name is first converted to ASCII using IDN before resolution.
     *
     * @param host the host name to resolve
     * @return an array of IP addresses for the host
     * @throws UnknownHostException if the host name cannot be resolved
     */
    @Override
    public InetAddress[] resolve(final String host) throws UnknownHostException {
        return InetAddress.getAllByName(toAscii(host));
    }

    /**

 *   It is similar to a Promise in JavaScript.
 *   It allows you to register callbacks that will be executed when the computation is complete,
 *   either successfully (resolve) or with an error (reject).
 * </p>
 *
 * <p>
 *   The Deferred class has a Promise inner class that allows you to register callbacks
 *   to be executed when the computation is complete.

        super(indexSettings, name, settings);

        final String suffixWordsPath = settings.get("suffix_words_path");

        if (suffixWordsPath != null) {
            final File suffixWordsFile = environment.configDir().resolve(suffixWordsPath).toFile();
            try (Reader reader = IOUtils.getDecodingReader(new FileInputStream(suffixWordsFile), StandardCharsets.UTF_8)) {
                suffixWords = WordlistLoader.getWordSet(reader);

        }
        return deferred.promise();
    }

    /**
     * Processes the request.
     * @param client The OpenSearch client.
     * @param deferred The Deferred object to resolve or reject the response.
     */
    protected abstract void processRequest(Client client, Deferred<T> deferred);

    /**
     * Returns a validation error message, or null if there are no errors.

                if (filePath == null) {
                    throw new IllegalArgumentException("synonyms_path is not found.");
                }

                final Path path = env.configDir().resolve(filePath);

                try {
                    final File file = path.toFile();
                    if (file.exists()) {
                        reloadableFile = file;
                    }

            final Settings settings) {
        super(indexSettings, name, settings);

        final String path = settings.get("keywords_path");
        if (path != null) {
            keywordPath = environment.configDir().resolve(path);
        } else {
            keywordPath = null;
        }

        reloadInterval = settings.getAsTime("reload_interval", TimeValue.timeValueMinutes(1)).getMillis();
    }

    @Override

            final Settings settings) {
        super(indexSettings, name, settings);

        final String path = settings.get("stopwords_path");
        if (path != null) {
            stopwordPath = environment.configDir().resolve(path);
        } else {
            stopwordPath = null;
        }

        ignoreCase = settings.getAsBoolean("ignore_case", false);

 * URLs using these rules.</p>
 *
 * <p>The conversion is performed by iterating through the conversion map and applying
 * each replacement rule sequentially. The order of the rules in the map is preserved
 * during the conversion process.</p>
 *
 * <p>Example usage:</p>
 *
 * <pre>{@code
 * UrlConvertHelper helper = new UrlConvertHelper();
 * helper.add("old-domain.com", "new-domain.com");

                    deferred.reject(new SuggesterException("Search failure. Failed shards num:" + searchResponse.getFailedShards()));
                } else {
                    deferred.resolve(createResponse(searchResponse));
                }
            }

            @Override
            public void onFailure(final Exception e) {
                deferred.reject(e);
            }
        });