From 0f7f0845f431eab028576e612d17fd2e171dc4ac Mon Sep 17 00:00:00 2001
From: Artem Bilan <abilan@vmware.com>
Date: Wed, 8 Jul 2020 12:51:00 -0400
Subject: [PATCH] Remove overrides from IntegrationFlowDefinition

Since we don't need a backward bytecode compatibility since this version,
we don't need methods override in the `IntegrationFlowDefinition` any more
---
 .../dsl/IntegrationFlowDefinition.java        | 836 ------------------
 1 file changed, 836 deletions(-)

diff --git a/spring-integration-core/src/main/java/org/springframework/integration/dsl/IntegrationFlowDefinition.java b/spring-integration-core/src/main/java/org/springframework/integration/dsl/IntegrationFlowDefinition.java
index 03dbd9914d..346bc31c99 100644
--- a/spring-integration-core/src/main/java/org/springframework/integration/dsl/IntegrationFlowDefinition.java
+++ b/spring-integration-core/src/main/java/org/springframework/integration/dsl/IntegrationFlowDefinition.java
@@ -16,38 +16,16 @@
 
 package org.springframework.integration.dsl;
 
-import java.util.Map;
-import java.util.concurrent.Executor;
 import java.util.function.Consumer;
 import java.util.function.Function;
 
-import org.reactivestreams.Publisher;
-
-import org.springframework.expression.Expression;
 import org.springframework.integration.core.GenericSelector;
-import org.springframework.integration.handler.BridgeHandler;
 import org.springframework.integration.handler.GenericHandler;
-import org.springframework.integration.handler.LoggingHandler;
-import org.springframework.integration.handler.MessageTriggerAction;
 import org.springframework.integration.handler.ServiceActivatingHandler;
-import org.springframework.integration.router.AbstractMessageRouter;
-import org.springframework.integration.router.ErrorMessageExceptionTypeRouter;
-import org.springframework.integration.router.ExpressionEvaluatingRouter;
 import org.springframework.integration.router.MethodInvokingRouter;
-import org.springframework.integration.splitter.AbstractMessageSplitter;
-import org.springframework.integration.splitter.DefaultMessageSplitter;
-import org.springframework.integration.splitter.ExpressionEvaluatingSplitter;
 import org.springframework.integration.splitter.MethodInvokingSplitter;
-import org.springframework.integration.store.MessageStore;
-import org.springframework.integration.support.MapBuilder;
 import org.springframework.integration.transformer.GenericTransformer;
-import org.springframework.integration.transformer.HeaderFilter;
 import org.springframework.integration.transformer.MessageTransformingHandler;
-import org.springframework.messaging.Message;
-import org.springframework.messaging.MessageChannel;
-import org.springframework.messaging.MessageHandler;
-
-import reactor.core.publisher.Flux;
 
 /**
  * The {@code BaseIntegrationFlowDefinition} extension for syntax sugar with generics for some
@@ -270,818 +248,4 @@ public abstract class IntegrationFlowDefinition<B extends IntegrationFlowDefinit
 		return route(null, router, routerConfigurer);
 	}
 
-
-	// All the methods below override super for byte code backward compatibility.
-
-	@Override
-	public B fixedSubscriberChannel() { // NOSONAR - byte code backward compatibility
-		return super.fixedSubscriberChannel();
-	}
-
-	@Override
-	public B fixedSubscriberChannel(String messageChannelName) { // NOSONAR - byte code backward compatibility
-		return super.fixedSubscriberChannel(messageChannelName);
-	}
-
-	@Override
-	public B channel(String messageChannelName) { // NOSONAR - byte code backward compatibility
-		return super.channel(messageChannelName);
-	}
-
-	@Override
-	public B channel(MessageChannelSpec<?, ?> messageChannelSpec) { // NOSONAR - byte code backward compatibility
-		return super.channel(messageChannelSpec);
-	}
-
-	@Override
-	public B channel(MessageChannel messageChannel) { // NOSONAR - byte code backward compatibility
-		return super.channel(messageChannel);
-	}
-
-	@Override
-	public B channel(Function<Channels, MessageChannelSpec<?, ?>> channels) { // NOSONAR - byte code backward compatibility
-		return super.channel(channels);
-	}
-
-	@Override
-	public B publishSubscribeChannel(Consumer<PublishSubscribeSpec> publishSubscribeChannelConfigurer) { // NOSONAR - byte code backward compatibility
-		return super.publishSubscribeChannel(publishSubscribeChannelConfigurer);
-	}
-
-	@Override
-	public B publishSubscribeChannel(Executor executor,
-			Consumer<PublishSubscribeSpec> publishSubscribeChannelConfigurer) { // NOSONAR - byte code backward compatibility
-
-		return super.publishSubscribeChannel(executor, publishSubscribeChannelConfigurer);
-	}
-
-	@Override
-	public B wireTap(IntegrationFlow flow) { // NOSONAR - byte code backward compatibility
-		return super.wireTap(flow);
-	}
-
-	@Override
-	public B wireTap(String wireTapChannel) { // NOSONAR - byte code backward compatibility
-		return super.wireTap(wireTapChannel);
-	}
-
-	@Override
-	public B wireTap(MessageChannel wireTapChannel) { // NOSONAR - byte code backward compatibility
-		return super.wireTap(wireTapChannel);
-	}
-
-	@Override
-	public B wireTap(IntegrationFlow flow, Consumer<WireTapSpec> wireTapConfigurer) { // NOSONAR - byte code backward compatibility
-		return super.wireTap(flow, wireTapConfigurer);
-	}
-
-	@Override
-	public B wireTap(String wireTapChannel, Consumer<WireTapSpec> wireTapConfigurer) { // NOSONAR - byte code backward compatibility
-		return super.wireTap(wireTapChannel, wireTapConfigurer);
-	}
-
-	@Override
-	public B wireTap(MessageChannel wireTapChannel, Consumer<WireTapSpec> wireTapConfigurer) { // NOSONAR - byte code backward compatibility
-		return super.wireTap(wireTapChannel, wireTapConfigurer);
-	}
-
-	@Override
-	public B wireTap(WireTapSpec wireTapSpec) { // NOSONAR - byte code backward compatibility
-		return super.wireTap(wireTapSpec);
-	}
-
-	@Override
-	public B controlBus() { // NOSONAR - byte code backward compatibility
-		return super.controlBus();
-	}
-
-	@Override
-	public B controlBus(Consumer<GenericEndpointSpec<ServiceActivatingHandler>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-		return super.controlBus(endpointConfigurer);
-	}
-
-	@Override
-	public B transform(String expression) { // NOSONAR - byte code backward compatibility
-		return super.transform(expression);
-	}
-
-	@Override
-	public B transform(String expression,
-			Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-
-		return super.transform(expression, endpointConfigurer);
-	}
-
-	@Override
-	public B transform(Object service) { // NOSONAR - byte code backward compatibility
-		return super.transform(service);
-	}
-
-	@Override
-	public B transform(Object service, String methodName) { // NOSONAR - byte code backward compatibility
-		return super.transform(service, methodName);
-	}
-
-	@Override
-	public B transform(Object service, String methodName,
-			Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-
-		return super.transform(service, methodName, endpointConfigurer);
-	}
-
-	@Override
-	public B transform(MessageProcessorSpec<?> messageProcessorSpec) { // NOSONAR - byte code backward compatibility
-		return super.transform(messageProcessorSpec);
-	}
-
-	@Override
-	public B transform(MessageProcessorSpec<?> messageProcessorSpec,
-			Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-
-		return super.transform(messageProcessorSpec, endpointConfigurer);
-	}
-
-	@Override
-	public <P> B convert(Class<P> payloadType) { // NOSONAR - byte code backward compatibility
-		return super.convert(payloadType);
-	}
-
-	@Override
-	public <P, T> B transform(Class<P> payloadType, GenericTransformer<P, T> genericTransformer) { // NOSONAR - byte code backward compatibility
-		return super.transform(payloadType, genericTransformer);
-	}
-
-	@Override
-	public <P> B convert(Class<P> payloadType,
-			Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-		return super.convert(payloadType, endpointConfigurer);
-	}
-
-	@Override
-	public <P, T> B transform(Class<P> payloadType, GenericTransformer<P, T> genericTransformer,
-			Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-
-		return super.transform(payloadType, genericTransformer, endpointConfigurer);
-	}
-
-	@Override
-	public B filter(String expression) { // NOSONAR - byte code backward compatibility
-		return super.filter(expression);
-	}
-
-	@Override
-	public B filter(String expression, Consumer<FilterEndpointSpec> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-		return super.filter(expression, endpointConfigurer);
-	}
-
-	@Override
-	public B filter(Object service) { // NOSONAR - byte code backward compatibility
-		return super.filter(service);
-	}
-
-	@Override
-	public B filter(Object service, String methodName) { // NOSONAR - byte code backward compatibility
-		return super.filter(service, methodName);
-	}
-
-	@Override
-	public B filter(Object service, String methodName, Consumer<FilterEndpointSpec> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-		return super.filter(service, methodName, endpointConfigurer);
-	}
-
-	@Override
-	public B filter(MessageProcessorSpec<?> messageProcessorSpec) { // NOSONAR - byte code backward compatibility
-		return super.filter(messageProcessorSpec);
-	}
-
-	@Override
-	public B filter(MessageProcessorSpec<?> messageProcessorSpec, Consumer<FilterEndpointSpec> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-		return super.filter(messageProcessorSpec, endpointConfigurer);
-	}
-
-	@Override
-	public <P> B filter(Class<P> payloadType, GenericSelector<P> genericSelector) { // NOSONAR - byte code backward compatibility
-		return super.filter(payloadType, genericSelector);
-	}
-
-	@Override
-	public <P> B filter(Class<P> payloadType, GenericSelector<P> genericSelector,
-			Consumer<FilterEndpointSpec> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-
-		return super.filter(payloadType, genericSelector, endpointConfigurer);
-	}
-
-	@Override
-	public <H extends MessageHandler> B handle(MessageHandlerSpec<?, H> messageHandlerSpec) { // NOSONAR - byte code backward compatibility
-		return super.handle(messageHandlerSpec);
-	}
-
-	@Override
-	public B handle(MessageHandler messageHandler) { // NOSONAR - byte code backward compatibility
-		return super.handle(messageHandler);
-	}
-
-	@Override
-	public B handle(String beanName, String methodName) { // NOSONAR - byte code backward compatibility
-		return super.handle(beanName, methodName);
-	}
-
-	@Override
-	public B handle(String beanName, String methodName,
-			Consumer<GenericEndpointSpec<ServiceActivatingHandler>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-
-		return super.handle(beanName, methodName, endpointConfigurer);
-	}
-
-	@Override
-	public B handle(Object service) { // NOSONAR - byte code backward compatibility
-		return super.handle(service);
-	}
-
-	@Override
-	public B handle(Object service, String methodName) { // NOSONAR - byte code backward compatibility
-		return super.handle(service, methodName);
-	}
-
-	@Override
-	public B handle(Object service, String methodName,
-			Consumer<GenericEndpointSpec<ServiceActivatingHandler>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-
-		return super.handle(service, methodName, endpointConfigurer);
-	}
-
-	@Override
-	public <P> B handle(Class<P> payloadType, GenericHandler<P> handler) { // NOSONAR - byte code backward compatibility
-		return super.handle(payloadType, handler);
-	}
-
-	@Override
-	public <P> B handle(Class<P> payloadType, GenericHandler<P> handler,
-			Consumer<GenericEndpointSpec<ServiceActivatingHandler>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-
-		return super.handle(payloadType, handler, endpointConfigurer);
-	}
-
-	@Override
-	public B handle(MessageProcessorSpec<?> messageProcessorSpec) { // NOSONAR - byte code backward compatibility
-		return super.handle(messageProcessorSpec);
-	}
-
-	@Override
-	public B handle(MessageProcessorSpec<?> messageProcessorSpec,
-			Consumer<GenericEndpointSpec<ServiceActivatingHandler>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-
-		return super.handle(messageProcessorSpec, endpointConfigurer);
-	}
-
-	@Override
-	public <H extends MessageHandler> B handle(MessageHandlerSpec<?, H> messageHandlerSpec,
-			Consumer<GenericEndpointSpec<H>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-
-		return super.handle(messageHandlerSpec, endpointConfigurer);
-	}
-
-	@Override
-	public <H extends MessageHandler> B handle(H messageHandler, Consumer<GenericEndpointSpec<H>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-		return super.handle(messageHandler, endpointConfigurer);
-	}
-
-	@Override
-	public B bridge() { // NOSONAR - byte code backward compatibility
-		return super.bridge();
-	}
-
-	@Override
-	public B bridge(Consumer<GenericEndpointSpec<BridgeHandler>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-		return super.bridge(endpointConfigurer);
-	}
-
-	@Override
-	public B delay(String groupId) { // NOSONAR - byte code backward compatibility
-		return super.delay(groupId);
-	}
-
-	@Override
-	public B delay(String groupId, Consumer<DelayerEndpointSpec> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-		return super.delay(groupId, endpointConfigurer);
-	}
-
-	@Override
-	public B enrich(Consumer<EnricherSpec> enricherConfigurer) { // NOSONAR - byte code backward compatibility
-		return super.enrich(enricherConfigurer);
-	}
-
-	@Override
-	public B enrichHeaders(MapBuilder<?, String, Object> headers) { // NOSONAR - byte code backward compatibility
-		return super.enrichHeaders(headers);
-	}
-
-	@Override
-	public B enrichHeaders(MapBuilder<?, String, Object> headers,
-			Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-
-		return super.enrichHeaders(headers, endpointConfigurer);
-	}
-
-	@Override
-	public B enrichHeaders(Map<String, Object> headers,
-			Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-
-		return super.enrichHeaders(headers, endpointConfigurer);
-	}
-
-	@Override
-	public B enrichHeaders(Consumer<HeaderEnricherSpec> headerEnricherConfigurer) { // NOSONAR - byte code backward compatibility
-		return super.enrichHeaders(headerEnricherConfigurer);
-	}
-
-	@Override
-	public B split() { // NOSONAR - byte code backward compatibility
-		return super.split();
-	}
-
-	@Override
-	public B split(Consumer<SplitterEndpointSpec<DefaultMessageSplitter>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-		return super.split(endpointConfigurer);
-	}
-
-	@Override
-	public B split(String expression) { // NOSONAR - byte code backward compatibility
-		return super.split(expression);
-	}
-
-	@Override
-	public B split(String expression, Consumer<SplitterEndpointSpec<ExpressionEvaluatingSplitter>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-		return super.split(expression, endpointConfigurer);
-	}
-
-	@Override
-	public B split(Object service) { // NOSONAR - byte code backward compatibility
-		return super.split(service);
-	}
-
-	@Override
-	public B split(Object service, String methodName) { // NOSONAR - byte code backward compatibility
-		return super.split(service, methodName);
-	}
-
-	@Override
-	public B split(Object service, String methodName,
-			Consumer<SplitterEndpointSpec<MethodInvokingSplitter>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-
-		return super.split(service, methodName, endpointConfigurer);
-	}
-
-	@Override
-	public B split(String beanName, String methodName) { // NOSONAR - byte code backward compatibility
-		return super.split(beanName, methodName);
-	}
-
-	@Override
-	public B split(String beanName, String methodName,
-			Consumer<SplitterEndpointSpec<MethodInvokingSplitter>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-
-		return super.split(beanName, methodName, endpointConfigurer);
-	}
-
-	@Override
-	public B split(MessageProcessorSpec<?> messageProcessorSpec) { // NOSONAR - byte code backward compatibility
-		return super.split(messageProcessorSpec);
-	}
-
-	@Override
-	public B split(MessageProcessorSpec<?> messageProcessorSpec,
-			Consumer<SplitterEndpointSpec<MethodInvokingSplitter>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-
-		return super.split(messageProcessorSpec, endpointConfigurer);
-	}
-
-	@Override
-	public <P> B split(Class<P> payloadType, Function<P, ?> splitter) { // NOSONAR - byte code backward compatibility
-		return super.split(payloadType, splitter);
-	}
-
-	@Override
-	public <P> B split(Class<P> payloadType, Function<P, ?> splitter,
-			Consumer<SplitterEndpointSpec<MethodInvokingSplitter>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-
-		return super.split(payloadType, splitter, endpointConfigurer);
-	}
-
-	@Override
-	public <S extends AbstractMessageSplitter> B split(MessageHandlerSpec<?, S> splitterMessageHandlerSpec) { // NOSONAR - byte code backward compatibility
-		return super.split(splitterMessageHandlerSpec);
-	}
-
-	@Override
-	public <S extends AbstractMessageSplitter> B split(MessageHandlerSpec<?, S> splitterMessageHandlerSpec,
-			Consumer<SplitterEndpointSpec<S>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-
-		return super.split(splitterMessageHandlerSpec, endpointConfigurer);
-	}
-
-	@Override
-	public B split(AbstractMessageSplitter splitter) { // NOSONAR - byte code backward compatibility
-		return super.split(splitter);
-	}
-
-	@Override
-	public <S extends AbstractMessageSplitter> B split(S splitter,
-			Consumer<SplitterEndpointSpec<S>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-		return super.split(splitter, endpointConfigurer);
-	}
-
-	@Override
-	public B headerFilter(String... headersToRemove) { // NOSONAR - byte code backward compatibility
-		return super.headerFilter(headersToRemove);
-	}
-
-	@Override
-	public B headerFilter(String headersToRemove, boolean patternMatch) { // NOSONAR - byte code backward compatibility
-		return super.headerFilter(headersToRemove, patternMatch);
-	}
-
-	@Override
-	public B headerFilter(HeaderFilter headerFilter,
-			Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-		return super.headerFilter(headerFilter, endpointConfigurer);
-	}
-
-	@Override
-	public B claimCheckIn(MessageStore messageStore) { // NOSONAR - byte code backward compatibility
-		return super.claimCheckIn(messageStore);
-	}
-
-	@Override
-	public B claimCheckIn(MessageStore messageStore,
-			Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-		return super.claimCheckIn(messageStore, endpointConfigurer);
-	}
-
-	@Override
-	public B claimCheckOut(MessageStore messageStore) { // NOSONAR - byte code backward compatibility
-		return super.claimCheckOut(messageStore);
-	}
-
-	@Override
-	public B claimCheckOut(MessageStore messageStore, boolean removeMessage) { // NOSONAR - byte code backward compatibility
-		return super.claimCheckOut(messageStore, removeMessage);
-	}
-
-	@Override
-	public B claimCheckOut(MessageStore messageStore, boolean removeMessage,
-			Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-
-		return super.claimCheckOut(messageStore, removeMessage, endpointConfigurer);
-	}
-
-	@Override
-	public B resequence() { // NOSONAR - byte code backward compatibility
-		return super.resequence();
-	}
-
-	@Override
-	public B resequence(Consumer<ResequencerSpec> resequencer) { // NOSONAR - byte code backward compatibility
-		return super.resequence(resequencer);
-	}
-
-	@Override
-	public B aggregate() { // NOSONAR - byte code backward compatibility
-		return super.aggregate();
-	}
-
-	@Override
-	public B aggregate(Consumer<AggregatorSpec> aggregator) { // NOSONAR - byte code backward compatibility
-		return super.aggregate(aggregator);
-	}
-
-	@Override
-	public B route(String beanName, String method) { // NOSONAR - byte code backward compatibility
-		return super.route(beanName, method);
-	}
-
-	@Override
-	public B route(String beanName, String method,
-			Consumer<RouterSpec<Object, MethodInvokingRouter>> routerConfigurer) { // NOSONAR - byte code backward compatibility
-
-		return super.route(beanName, method, routerConfigurer);
-	}
-
-	@Override
-	public B route(Object service) { // NOSONAR - byte code backward compatibility
-		return super.route(service);
-	}
-
-	@Override
-	public B route(Object service, String methodName) { // NOSONAR - byte code backward compatibility
-		return super.route(service, methodName);
-	}
-
-	@Override
-	public B route(Object service, String methodName,
-			Consumer<RouterSpec<Object, MethodInvokingRouter>> routerConfigurer) { // NOSONAR - byte code backward compatibility
-
-		return super.route(service, methodName, routerConfigurer);
-	}
-
-	@Override
-	public B route(String expression) { // NOSONAR - byte code backward compatibility
-		return super.route(expression);
-	}
-
-	@Override
-	public <T> B route(String expression, Consumer<RouterSpec<T, ExpressionEvaluatingRouter>> routerConfigurer) { // NOSONAR - byte code backward compatibility
-		return super.route(expression, routerConfigurer);
-	}
-
-	@Override
-	public <S, T> B route(Class<S> payloadType, Function<S, T> router) { // NOSONAR - byte code backward compatibility
-		return super.route(payloadType, router);
-	}
-
-	@Override
-	public <P, T> B route(Class<P> payloadType, Function<P, T> router,
-			Consumer<RouterSpec<T, MethodInvokingRouter>> routerConfigurer) { // NOSONAR - byte code backward compatibility
-		return super.route(payloadType, router, routerConfigurer);
-	}
-
-	@Override
-	public B route(MessageProcessorSpec<?> messageProcessorSpec) { // NOSONAR - byte code backward compatibility
-		return super.route(messageProcessorSpec);
-	}
-
-	@Override
-	public B route(MessageProcessorSpec<?> messageProcessorSpec,
-			Consumer<RouterSpec<Object, MethodInvokingRouter>> routerConfigurer) { // NOSONAR - byte code backward compatibility
-
-		return super.route(messageProcessorSpec, routerConfigurer);
-	}
-
-	@Override
-	public B routeToRecipients(Consumer<RecipientListRouterSpec> routerConfigurer) { // NOSONAR - byte code backward compatibility
-		return super.routeToRecipients(routerConfigurer);
-	}
-
-	@Override
-	public B routeByException(Consumer<RouterSpec<Class<? extends Throwable>,  // NOSONAR - byte code backward compatibility
-			ErrorMessageExceptionTypeRouter>> routerConfigurer) {
-
-		return super.routeByException(routerConfigurer);
-	}
-
-	@Override
-	public B route(AbstractMessageRouter router) { // NOSONAR - byte code backward compatibility
-		return super.route(router);
-	}
-
-	@Override
-	public <R extends AbstractMessageRouter> B route(R router, Consumer<GenericEndpointSpec<R>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-		return super.route(router, endpointConfigurer);
-	}
-
-	@Override
-	public B gateway(String requestChannel) { // NOSONAR - byte code backward compatibility
-		return super.gateway(requestChannel);
-	}
-
-	@Override
-	public B gateway(String requestChannel, Consumer<GatewayEndpointSpec> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-		return super.gateway(requestChannel, endpointConfigurer);
-	}
-
-	@Override
-	public B gateway(MessageChannel requestChannel) { // NOSONAR - byte code backward compatibility
-		return super.gateway(requestChannel);
-	}
-
-	@Override
-	public B gateway(MessageChannel requestChannel, Consumer<GatewayEndpointSpec> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-		return super.gateway(requestChannel, endpointConfigurer);
-	}
-
-	@Override
-	public B gateway(IntegrationFlow flow) { // NOSONAR - byte code backward compatibility
-		return super.gateway(flow);
-	}
-
-	@Override
-	public B gateway(IntegrationFlow flow, Consumer<GatewayEndpointSpec> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-		return super.gateway(flow, endpointConfigurer);
-	}
-
-	@Override
-	public B log() { // NOSONAR - byte code backward compatibility
-		return super.log();
-	}
-
-	@Override
-	public B log(LoggingHandler.Level level) { // NOSONAR - byte code backward compatibility
-		return super.log(level);
-	}
-
-	@Override
-	public B log(String category) { // NOSONAR - byte code backward compatibility
-		return super.log(category);
-	}
-
-	@Override
-	public B log(LoggingHandler.Level level, String category) { // NOSONAR - byte code backward compatibility
-		return super.log(level, category);
-	}
-
-	@Override
-	public B log(LoggingHandler.Level level, String category, String logExpression) { // NOSONAR - byte code backward compatibility
-		return super.log(level, category, logExpression);
-	}
-
-	@Override
-	public <P> B log(Function<Message<P>, Object> function) { // NOSONAR - byte code backward compatibility
-		return super.log(function);
-	}
-
-	@Override
-	public B log(Expression logExpression) { // NOSONAR - byte code backward compatibility
-		return super.log(logExpression);
-	}
-
-	@Override
-	public B log(LoggingHandler.Level level, Expression logExpression) { // NOSONAR - byte code backward compatibility
-		return super.log(level, logExpression);
-	}
-
-	@Override
-	public B log(String category, Expression logExpression) { // NOSONAR - byte code backward compatibility
-		return super.log(category, logExpression);
-	}
-
-	@Override
-	public <P> B log(LoggingHandler.Level level, Function<Message<P>, Object> function) { // NOSONAR - byte code backward compatibility
-		return super.log(level, function);
-	}
-
-	@Override
-	public <P> B log(String category, Function<Message<P>, Object> function) { // NOSONAR - byte code backward compatibility
-		return super.log(category, function);
-	}
-
-	@Override
-	public <P> B log(LoggingHandler.Level level, String category, Function<Message<P>, Object> function) { // NOSONAR - byte code backward compatibility
-		return super.log(level, category, function);
-	}
-
-	@Override
-	public B log(LoggingHandler.Level level, String category, Expression logExpression) { // NOSONAR - byte code backward compatibility
-		return super.log(level, category, logExpression);
-	}
-
-	@Override
-	public IntegrationFlow logAndReply() { // NOSONAR - byte code backward compatibility
-		return super.logAndReply();
-	}
-
-	@Override
-	public IntegrationFlow logAndReply(LoggingHandler.Level level) { // NOSONAR - byte code backward compatibility
-		return super.logAndReply(level);
-	}
-
-	@Override
-	public IntegrationFlow logAndReply(String category) { // NOSONAR - byte code backward compatibility
-		return super.logAndReply(category);
-	}
-
-	@Override
-	public IntegrationFlow logAndReply(LoggingHandler.Level level, String category) { // NOSONAR - byte code backward compatibility
-		return super.logAndReply(level, category);
-	}
-
-	@Override
-	public IntegrationFlow logAndReply(LoggingHandler.Level level, String category, String logExpression) { // NOSONAR - byte code backward compatibility
-		return super.logAndReply(level, category, logExpression);
-	}
-
-	@Override
-	public <P> IntegrationFlow logAndReply(Function<Message<P>, Object> function) { // NOSONAR - byte code backward compatibility
-		return super.logAndReply(function);
-	}
-
-	@Override
-	public IntegrationFlow logAndReply(Expression logExpression) { // NOSONAR - byte code backward compatibility
-		return super.logAndReply(logExpression);
-	}
-
-	@Override
-	public IntegrationFlow logAndReply(LoggingHandler.Level level, Expression logExpression) { // NOSONAR - byte code backward compatibility
-		return super.logAndReply(level, logExpression);
-	}
-
-	@Override
-	public IntegrationFlow logAndReply(String category, Expression logExpression) { // NOSONAR - byte code backward compatibility
-		return super.logAndReply(category, logExpression);
-	}
-
-	@Override
-	public <P> IntegrationFlow logAndReply(LoggingHandler.Level level, Function<Message<P>, Object> function) { // NOSONAR - byte code backward compatibility
-		return super.logAndReply(level, function);
-	}
-
-	@Override
-	public <P> IntegrationFlow logAndReply(String category, Function<Message<P>, Object> function) { // NOSONAR - byte code backward compatibility
-		return super.logAndReply(category, function);
-	}
-
-	@Override
-	public <P> IntegrationFlow logAndReply(LoggingHandler.Level level, String category,
-			Function<Message<P>, Object> function) { // NOSONAR - byte code backward compatibility
-
-		return super.logAndReply(level, category, function);
-	}
-
-	@Override
-	public IntegrationFlow logAndReply(LoggingHandler.Level level, String category, Expression logExpression) { // NOSONAR - byte code backward compatibility
-		return super.logAndReply(level, category, logExpression);
-	}
-
-	@Override
-	public B scatterGather(MessageChannel scatterChannel) { // NOSONAR - byte code backward compatibility
-		return super.scatterGather(scatterChannel);
-	}
-
-	@Override
-	public B scatterGather(MessageChannel scatterChannel, Consumer<AggregatorSpec> gatherer) { // NOSONAR - byte code backward compatibility
-		return super.scatterGather(scatterChannel, gatherer);
-	}
-
-	@Override
-	public B scatterGather(MessageChannel scatterChannel, Consumer<AggregatorSpec> gatherer,
-			Consumer<ScatterGatherSpec> scatterGather) { // NOSONAR - byte code backward compatibility
-
-		return super.scatterGather(scatterChannel, gatherer, scatterGather);
-	}
-
-	@Override
-	public B scatterGather(Consumer<RecipientListRouterSpec> scatterer) { // NOSONAR - byte code backward compatibility
-		return super.scatterGather(scatterer);
-	}
-
-	@Override
-	public B scatterGather(Consumer<RecipientListRouterSpec> scatterer, Consumer<AggregatorSpec> gatherer) { // NOSONAR - byte code backward compatibility
-		return super.scatterGather(scatterer, gatherer);
-	}
-
-	@Override
-	public B scatterGather(Consumer<RecipientListRouterSpec> scatterer, Consumer<AggregatorSpec> gatherer,
-			Consumer<ScatterGatherSpec> scatterGather) { // NOSONAR - byte code backward compatibility
-
-		return super.scatterGather(scatterer, gatherer, scatterGather);
-	}
-
-	@Override
-	public B barrier(long timeout) { // NOSONAR - byte code backward compatibility
-		return super.barrier(timeout);
-	}
-
-	@Override
-	public B barrier(long timeout, Consumer<BarrierSpec> barrierConfigurer) { // NOSONAR - byte code backward compatibility
-		return super.barrier(timeout, barrierConfigurer);
-	}
-
-	@Override
-	public B trigger(String triggerActionId) { // NOSONAR - byte code backward compatibility
-		return super.trigger(triggerActionId);
-	}
-
-	@Override
-	public B trigger(String triggerActionId,
-			Consumer<GenericEndpointSpec<ServiceActivatingHandler>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-
-		return super.trigger(triggerActionId, endpointConfigurer);
-	}
-
-	@Override
-	public B trigger(MessageTriggerAction triggerAction) { // NOSONAR - byte code backward compatibility
-		return super.trigger(triggerAction);
-	}
-
-	@Override
-	public B trigger(MessageTriggerAction triggerAction,
-			Consumer<GenericEndpointSpec<ServiceActivatingHandler>> endpointConfigurer) { // NOSONAR - byte code backward compatibility
-
-		return super.trigger(triggerAction, endpointConfigurer);
-	}
-
-	@Override
-	public <I, O> B fluxTransform(Function<? super Flux<Message<I>>, ? extends Publisher<O>> fluxFunction) { // NOSONAR - byte code backward compatibility
-		return super.fluxTransform(fluxFunction);
-	}
-
-	@Override
-	public IntegrationFlow nullChannel() { // NOSONAR - byte code backward compatibility
-		return super.nullChannel();
-	}
-
-	@Override
-	public B enrichHeaders(Map<String, Object> headers) { // NOSONAR - byte code backward compatibility
-		return super.enrichHeaders(headers);
-	}
-
 }