this.clientConfiguration = clientConfiguration;
        }

        @Override
        public void execute(ModuleDependency moduleDependency) {
            ((MutationValidator) clientConfiguration).validateMutation(MutationValidator.MutationType.DEPENDENCY_ATTRIBUTES);
        }
    }

            return displayName;
        }
    }

    /**
     * Check if mutation is allowed.
     *
     * @param type the type of mutation to validate.
     */
    void validateMutation(MutationType type);

    MutationValidator IGNORE = type -> {
    };

    }

    @Override
    public ComponentSelectionRules addRule(SpecRuleAction<? super ComponentSelection> specRuleAction) {
        mutationValidator.validateMutation(STRATEGY);
        if (rules == null) {
            rules = new LinkedHashSet<>();
        }
        rules.add(specRuleAction);
        return this;
    }

    @Override

        for (String lockExcludes : dependencyNotations) {
            for (String lockExclude : lockExcludes.split(",")) {
                String[] split = lockExclude.split(MODULE_SEPARATOR);
                validateNotation(lockExclude, split, allowFullWildcard, context);

                lockEntryFilters.add(createFilter(split[0], split[1]));
            }
            if (lockEntryFilters.isEmpty()) {

	errs = AppendValidation(errs, validateHTTPRouteDestinations(http.Route, gatewaySemantics))
	if http.Timeout != nil {
		errs = AppendValidation(errs, agent.ValidateDuration(http.Timeout))
	}

	return
}

// validateAuthorityRewrite ensures we only attempt rewrite authority in a single place.