private List<ValidationEvent> validateOperation(
            HttpBindingIndex bindingIndex,
            OperationShape shape,
            HttpTrait trait
    ) {
        String method = trait.getMethod().toUpperCase(Locale.US);

        // We don't have a standard method, so we can't validate it.
        if (!EXPECTED.containsKey(method)) {
            return ListUtils.of();
        }

        List<ValidationEvent> events = new ArrayList<>();

        // Emit a warning if the method is standard, but doesn't match standard casing.
        if (!EXPECTED.containsKey(trait.getMethod())) {
            events.add(warning(shape,
                    trait,
                    String.format(
                            "This operation uses the `%s` method in the `http` trait, but expected `%s`.",
                            trait.getMethod(),
                            method)));
        }

        HttpMethodSemantics semantics = EXPECTED.get(method);

        if (semantics.warningWhenModeled != null) {
            events.add(warning(shape, trait, semantics.warningWhenModeled, method));
        }

        boolean isReadonly = shape.hasTrait(ReadonlyTrait.ID);
        if (semantics.isReadonly != null && semantics.isReadonly != isReadonly) {
            events.add(warning(shape,
                    trait,
                    String.format(
                            "This operation uses the `%s` method in the `http` trait, but %s marked with the readonly trait",
                            method,
                            isReadonly ? "is" : "is not"),
                    isReadonly ? UNNECESSARY_READONLY_TRAIT : MISSING_READONLY_TRAIT));
        }

        boolean isIdempotent = shape.hasTrait(IdempotentTrait.ID);
        if (semantics.isIdempotent != null && semantics.isIdempotent != isIdempotent) {
            events.add(warning(shape,
                    trait,
                    String.format(
                            "This operation uses the `%s` method in the `http` trait, but %s marked with the idempotent trait",
                            method,
                            isIdempotent ? "is" : "is not"),
                    isIdempotent ? UNNECESSARY_IDEMPOTENT_TRAIT : MISSING_IDEMPOTENT_TRAIT));
        }

        List<HttpBinding> payloadBindings = bindingIndex.getRequestBindings(shape, HttpBinding.Location.PAYLOAD);
        List<HttpBinding> documentBindings = bindingIndex.getRequestBindings(shape, HttpBinding.Location.DOCUMENT);
        if (semantics.allowsRequestPayload != null && !semantics.allowsRequestPayload) {
            if (!payloadBindings.isEmpty()) {
                events.add(danger(shape,
                        trait,
                        String.format(
                                "This operation uses the `%s` method in the `http` trait, but the `%s` member is sent as the "
                                        + "payload of the request because it is marked with the `httpPayload` trait. Many HTTP "
                                        + "clients do not support payloads with %1$s requests. Consider binding this member to "
                                        + "other parts of the HTTP request such as a query string parameter using the `httpQuery` "
                                        + "trait, a header using the `httpHeader` trait, or a path segment using the `httpLabel` "
                                        + "trait.",
                                method,
                                payloadBindings.get(0).getMemberName()),
                        UNEXPECTED_PAYLOAD));
            } else if (!documentBindings.isEmpty()) {
                events.add(danger(shape,
                        trait,
                        String.format(
                                "This operation uses the `%s` method in the `http` trait, but the following members "
                                        + "are sent as part of the payload of the request: %s. These members are sent as part "
                                        + "of the payload because they are not explicitly configured to be sent in headers, in the "
                                        + "query string, or in a URI segment. Many HTTP clients do not support payloads with %1$s "
                                        + "requests. Consider binding these members to other parts of the HTTP request such as "
                                        + "query string parameters using the `httpQuery` trait, headers using the `httpHeader` "
                                        + "trait, or URI segments using the `httpLabel` trait.",
                                method,
                                ValidationUtils.tickedList(documentBindings.stream().map(HttpBinding::getMemberName))),
                        UNEXPECTED_PAYLOAD));
            }
        }

        return events;
    }
Provides the configuration for each HTTP method name:

<ul>
    <li>Key: (String) method</li>
    <li>(Boolean) isReadonly</li>
    <li>(Boolean) isIdempotent</li>
    <li>(Boolean) allowsRequestPayload</li>
    <li>(Boolean) warningMessageWhenModeled</li>
</ul>

<p>Setting any of the Boolean properties to {@code null} means that
the validator will have no enforced semantic on a specific property.
smithy-model/src/main/java/software/amazon/smithy/model/validation/validators/HttpMethodSemanticsValidator.java