.stream()
            .collect(Collectors.toMap(file -> rootDir.relativize(file.toURI()).toString(), ChangelogEntry::parse));

        // We don't try to find all such errors, because we expect them to be rare e.g. only
        // when a new file is added.
        changelogs.forEach((path, entry) -> {
            final String type = entry.getType();

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.exception;

/**
 * Exception thrown when web API operations encounter errors.
 * This exception includes an HTTP status code to indicate the nature of the error.
 */
public class WebApiException extends FessSystemException {

    private static final long serialVersionUID = 1L;

    /**

            git push
          fi
      - uses: pre-commit-ci/lite-action@v1.1.0
        if: env.HAS_SECRETS == 'false'
        with:
          msg: 🎨 Auto format
      - name: Error out on pre-commit errors
        if: steps.precommit.outcome == 'failure'
        run: exit 1

  # https://github.com/marketplace/actions/alls-green#why

 *
 * This exception is typically thrown when query parsing, serialization,
 * or processing fails during search operations. It extends FessSystemException
 * to provide specific handling for search query-related errors.
 */
public class SearchQueryException extends FessSystemException {

    /** Serial version UID for serialization. */
    private static final long serialVersionUID = 1L;

    /**

    @Override
    public String toString() {
        return render("");
    }

    public String render(String indentation) {
        if (messages.isEmpty()) {
            return indentation + "There were no validation errors.";
        }

        StringBuilder message = new StringBuilder();
        for (int i = 0; i < messages.size(); i++) {
            message.append(indentation)
                    .append('[')

Java serialization is inherently Java-centric and does not support cross-language scenarios well.

- **Type Safety:**
Java serialization does not enforce type safety as strictly as some alternatives, potentially leading to runtime errors.

## Decision

We do not use Java serialization.
Instead, we use custom serialization where we explicitly describe how data objects should be serialized and deserialized.

# Versions to use.
CODE=2025c
DATA=2025c

set -e

cd $(dirname $0)
rm -rf work
mkdir work
go build -o work/mkzip mkzip.go # build now for correct paths in build errors
cd work
mkdir zoneinfo
curl -sS -L -O https://www.iana.org/time-zones/repository/releases/tzcode$CODE.tar.gz
curl -sS -L -O https://www.iana.org/time-zones/repository/releases/tzdata$DATA.tar.gz
tar xzf tzcode$CODE.tar.gz

func (w WebhookArgs) Validate() error {
	if !w.Enable {
		return nil
	}
	if w.Endpoint.IsEmpty() {
		return errors.New("endpoint empty")
	}
	if w.QueueDir != "" {
		if !filepath.IsAbs(w.QueueDir) {
			return errors.New("queueDir path should be absolute")
		}
	}
	if w.ClientCert != "" && w.ClientKey == "" || w.ClientCert == "" && w.ClientKey != "" {
		return errors.New("cert and key must be specified as a pair")
	}

func (restClient *ReconnectRESTClient) Close() error {
	return nil
}

var (
	errLockConflict = errors.New("lock conflict")
	errLockNotFound = errors.New("lock not found")
)

func toLockError(err error) error {
	if err == nil {
		return nil
	}

	switch err.Error() {
	case errLockConflict.Error():
		return errLockConflict
	case errLockNotFound.Error():
		return errLockNotFound
	}
	return err
}

		}
	}
	return stmt, err
}

func validateTableName(from *TableExpression) error {
	if !strings.EqualFold(from.Table.BaseKey.String(), baseTableName) {
		return errBadTableName(errors.New("table name must be `s3object`"))
	}

	if len(from.Table.PathExpr) > 0 {
		if !from.Table.PathExpr[0].ArrayWildcard {
			return errBadTableName(errors.New("keypath table name is invalid - please check the service documentation"))
		}
	}