session, trace, installationToolchainsSource, userToolchainsSource);
        }

        private static class DefaultToolchainsBuilderRequest extends BaseRequest<ProtoSession>
                implements ToolchainsBuilderRequest {
            private final Source installationToolchainsSource;
            private final Source userToolchainsSource;

            return new DefaultVersionResolverRequest(session, trace, artifactCoordinates, repositories, nature);
        }

        private static class DefaultVersionResolverRequest extends BaseRequest<Session>
                implements VersionRangeResolverRequest {
            private final ArtifactCoordinates artifactCoordinates;
            private final List<RemoteRepository> repositories;

    /** The path of the HTML: /advance.jsp */
    HtmlNext path_AdvanceJsp = new HtmlNext("/advance.jsp");

    /** The path of the HTML: /error/badRequest.jsp */
    HtmlNext path_Error_BadRequestJsp = new HtmlNext("/error/badRequest.jsp");

    /** The path of the HTML: /error/error.jsp */
    HtmlNext path_Error_ErrorJsp = new HtmlNext("/error/error.jsp");

                    projectSettingsSource,
                    userSettingsSource,
                    interpolationSource);
        }

        private static class DefaultSettingsBuilderRequest extends BaseRequest<ProtoSession>
                implements SettingsBuilderRequest {
            private final Source installationSettingsSource;
            private final Source projectSettingsSource;

                    session, trace, path, source, allowStubModel, recursive, processPlugins, repositories);
        }

        private static class DefaultProjectBuilderRequest extends BaseRequest<Session>
                implements ProjectBuilderRequest {
            private final Path path;
            private final Source source;
            private final boolean allowStubModel;

                    repositoryMerging,
                    repositories,
                    lifecycleBindingsInjector);
        }

        private static class DefaultModelBuilderRequest extends BaseRequest<Session> implements ModelBuilderRequest {
            private final RequestType requestType;
            private final boolean locationTracking;
            private final boolean recursive;

		Code:           "InvalidPrefixMarker",
		Description:    "Invalid marker prefix combination",
		HTTPStatusCode: http.StatusBadRequest,
	},
	ErrBadRequest: {
		Code:           "BadRequest",
		Description:    "400 BadRequest",
		HTTPStatusCode: http.StatusBadRequest,
	},
	ErrKeyTooLongError: {
		Code:           "KeyTooLongError",
		Description:    "Your key is too long",
		HTTPStatusCode: http.StatusBadRequest,

		if ok {
			tc.FuncName = "s3.ValidRequest"
			tc.ResponseRecorder.LogErrBody = true
		}

		writeErrorResponse(r.Context(), w, APIError{
			Code: "BadRequest",
			Description: fmt.Sprintf("An unsupported API call for method: %s at '%s'",
				r.Method, r.URL.Path),
			HTTPStatusCode: http.StatusBadRequest,
		}, r.URL)
	}
}

// gets host name for current node

                    pathScope,
                    pathTypeFilter,
                    targetVersion,
                    repositories);
        }

        static class DefaultDependencyResolverRequest extends BaseRequest<Session>
                implements DependencyResolverRequest {

            static final class AlwaysTrueFilter implements Predicate<PathType> {
                @Override

		apiErr := errorCodes.ToAPIErr(s3Err)
		// If not set, convert or use BadRequest
		if s3Err == ErrNone {
			apiErr = toAPIError(ctx, err)
			if apiErr.Code == "InternalError" {
				// Convert generic internal errors to bad requests.
				apiErr = APIError{
					Code:           "BadRequest",
					Description:    err.Error(),
					HTTPStatusCode: http.StatusBadRequest,
				}
			}