You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@kafka.apache.org by da...@apache.org on 2025/03/05 15:50:00 UTC

(kafka) branch trunk updated: Revert "KAFKA-18887: Implement Streams Admin APIs (#19049)"

This is an automated email from the ASF dual-hosted git repository.

davidarthur pushed a commit to branch trunk
in repository https://gitbox.apache.org/repos/asf/kafka.git


The following commit(s) were added to refs/heads/trunk by this push:
     new d86cb597902 Revert "KAFKA-18887: Implement Streams Admin APIs (#19049)"
d86cb597902 is described below

commit d86cb597902d32ce83f27d65b60df6700cb7a61d
Author: David Arthur <mu...@gmail.com>
AuthorDate: Wed Mar 5 10:49:11 2025 -0500

    Revert "KAFKA-18887: Implement Streams Admin APIs (#19049)"
    
    This reverts commit 017692e86c5e40402312ebdb4bdab82face30181.
---
 .../java/org/apache/kafka/clients/admin/Admin.java |  97 ---
 .../admin/AlterConsumerGroupOffsetsResult.java     |   2 +-
 .../admin/AlterStreamsGroupOffsetsOptions.java     |  29 -
 .../admin/AlterStreamsGroupOffsetsResult.java      |  52 --
 .../admin/DeleteStreamsGroupOffsetsOptions.java    |  31 -
 .../admin/DeleteStreamsGroupOffsetsResult.java     |  57 --
 .../clients/admin/DeleteStreamsGroupsOptions.java  |  30 -
 .../clients/admin/DeleteStreamsGroupsResult.java   |  57 --
 .../kafka/clients/admin/ForwardingAdmin.java       |  20 -
 .../kafka/clients/admin/KafkaAdminClient.java      |  33 -
 .../admin/ListStreamsGroupOffsetsOptions.java      |  44 --
 .../admin/ListStreamsGroupOffsetsResult.java       |  58 --
 .../clients/admin/ListStreamsGroupOffsetsSpec.java |  49 --
 .../kafka/clients/admin/KafkaAdminClientTest.java  | 864 +--------------------
 .../kafka/clients/admin/MockAdminClient.java       |  25 -
 .../TestingMetricsInterceptingAdminClient.java     |  29 -
 16 files changed, 12 insertions(+), 1465 deletions(-)

diff --git a/clients/src/main/java/org/apache/kafka/clients/admin/Admin.java b/clients/src/main/java/org/apache/kafka/clients/admin/Admin.java
index ca99e4e40b1..a0bb85899f8 100644
--- a/clients/src/main/java/org/apache/kafka/clients/admin/Admin.java
+++ b/clients/src/main/java/org/apache/kafka/clients/admin/Admin.java
@@ -940,31 +940,6 @@ public interface Admin extends AutoCloseable {
         return listConsumerGroupOffsets(groupSpecs, new ListConsumerGroupOffsetsOptions());
     }
 
-    /**
-     * List the Streams group offsets available in the cluster for the specified Streams groups.
-     *
-     * <em>Note</em>: this method effectively does the same as the corresponding consumer group method {@link Admin#listConsumerGroupOffsets} does.
-     *
-     * @param groupSpecs Map of Streams group ids to a spec that specifies the topic partitions of the group to list offsets for.
-     *
-     * @param options The options to use when listing the Streams group offsets.
-     * @return The ListStreamsGroupOffsetsResult
-     */
-    ListStreamsGroupOffsetsResult listStreamsGroupOffsets(Map<String, ListStreamsGroupOffsetsSpec> groupSpecs, ListStreamsGroupOffsetsOptions options);
-
-    /**
-     * List the Streams group offsets available in the cluster for the specified groups with the default options.
-     * <p>
-     * This is a convenience method for
-     * {@link #listStreamsGroupOffsets(Map, ListStreamsGroupOffsetsOptions)} with default options.
-     *
-     * @param groupSpecs Map of Streams group ids to a spec that specifies the topic partitions of the group to list offsets for.
-     * @return The ListStreamsGroupOffsetsResult.
-     */
-    default ListStreamsGroupOffsetsResult listStreamsGroupOffsets(Map<String, ListStreamsGroupOffsetsSpec> groupSpecs) {
-        return listStreamsGroupOffsets(groupSpecs, new ListStreamsGroupOffsetsOptions());
-    }
-
     /**
      * Delete consumer groups from the cluster.
      *
@@ -982,25 +957,6 @@ public interface Admin extends AutoCloseable {
         return deleteConsumerGroups(groupIds, new DeleteConsumerGroupsOptions());
     }
 
-    /**
-     * Delete Streams groups from the cluster.
-     *
-     * <em>Note</em>: this method effectively does the same as the corresponding consumer group method {@link Admin#deleteConsumerGroups} does.
-     *
-     * @param options The options to use when deleting a Streams group.
-     * @return The DeleteStreamsGroupsResult.
-     */
-    DeleteStreamsGroupsResult deleteStreamsGroups(Collection<String> groupIds, DeleteStreamsGroupsOptions options);
-
-    /**
-     * Delete Streams groups from the cluster with the default options.
-     *
-     * @return The DeleteStreamsGroupResult.
-     */
-    default DeleteStreamsGroupsResult deleteStreamsGroups(Collection<String> groupIds) {
-        return deleteStreamsGroups(groupIds, new DeleteStreamsGroupsOptions());
-    }
-
     /**
      * Delete committed offsets for a set of partitions in a consumer group. This will
      * succeed at the partition level only if the group is not actively subscribed
@@ -1024,31 +980,6 @@ public interface Admin extends AutoCloseable {
         return deleteConsumerGroupOffsets(groupId, partitions, new DeleteConsumerGroupOffsetsOptions());
     }
 
-    /**
-     * Delete committed offsets for a set of partitions in a Streams group. This will
-     * succeed at the partition level only if the group is not actively subscribed
-     * to the corresponding topic.
-     *
-     * <em>Note</em>: this method effectively does the same as the corresponding consumer group method {@link Admin#deleteConsumerGroupOffsets} does.
-     *
-     * @param options The options to use when deleting offsets in a Streams group.
-     * @return The DeleteStreamsGroupOffsetsResult.
-     */
-    DeleteStreamsGroupOffsetsResult deleteStreamsGroupOffsets(String groupId,
-                                                                Set<TopicPartition> partitions,
-                                                                DeleteStreamsGroupOffsetsOptions options);
-
-    /**
-     * Delete committed offsets for a set of partitions in a Streams group with the default
-     * options. This will succeed at the partition level only if the group is not actively
-     * subscribed to the corresponding topic.
-     *
-     * @return The DeleteStreamsGroupOffsetsResult.
-     */
-    default DeleteStreamsGroupOffsetsResult deleteStreamsGroupOffsets(String groupId, Set<TopicPartition> partitions) {
-        return deleteStreamsGroupOffsets(groupId, partitions, new DeleteStreamsGroupOffsetsOptions());
-    }
-
     /**
      * List the groups available in the cluster with the default options.
      *
@@ -1282,34 +1213,6 @@ public interface Admin extends AutoCloseable {
      */
     AlterConsumerGroupOffsetsResult alterConsumerGroupOffsets(String groupId, Map<TopicPartition, OffsetAndMetadata> offsets, AlterConsumerGroupOffsetsOptions options);
 
-    /**
-     * <p>Alters offsets for the specified group. In order to succeed, the group must be empty.
-     *
-     * <p>This is a convenience method for {@link #alterStreamsGroupOffsets(String, Map, AlterStreamsGroupOffsetsOptions)} with default options.
-     * See the overload for more details.
-     *
-     * @param groupId The group for which to alter offsets.
-     * @param offsets A map of offsets by partition with associated metadata.
-     * @return The AlterOffsetsResult.
-     */
-    default AlterStreamsGroupOffsetsResult alterStreamsGroupOffsets(String groupId, Map<TopicPartition, OffsetAndMetadata> offsets) {
-        return alterStreamsGroupOffsets(groupId, offsets, new AlterStreamsGroupOffsetsOptions());
-    }
-
-    /**
-     * <p>Alters offsets for the specified group. In order to succeed, the group must be empty.
-     *
-     * <p>This operation is not transactional so it may succeed for some partitions while fail for others.
-     *
-     * <em>Note</em>: this method effectively does the same as the corresponding consumer group method {@link Admin#alterConsumerGroupOffsets} does.
-     *
-     * @param groupId The group for which to alter offsets.
-     * @param offsets A map of offsets by partition with associated metadata. Partitions not specified in the map are ignored.
-     * @param options The options to use when altering the offsets.
-     * @return The AlterOffsetsResult.
-     */
-    AlterStreamsGroupOffsetsResult alterStreamsGroupOffsets(String groupId, Map<TopicPartition, OffsetAndMetadata> offsets, AlterStreamsGroupOffsetsOptions options);
-
     /**
      * <p>List offset for the specified partitions and OffsetSpec. This operation enables to find
      * the beginning offset, end offset as well as the offset matching a timestamp in partitions.
diff --git a/clients/src/main/java/org/apache/kafka/clients/admin/AlterConsumerGroupOffsetsResult.java b/clients/src/main/java/org/apache/kafka/clients/admin/AlterConsumerGroupOffsetsResult.java
index 8d78a16b574..0dc1bd14e18 100644
--- a/clients/src/main/java/org/apache/kafka/clients/admin/AlterConsumerGroupOffsetsResult.java
+++ b/clients/src/main/java/org/apache/kafka/clients/admin/AlterConsumerGroupOffsetsResult.java
@@ -74,7 +74,7 @@ public class AlterConsumerGroupOffsetsResult {
             for (Errors error : topicPartitionErrorsMap.values()) {
                 if (error != Errors.NONE) {
                     throw error.exception(
-                        "Failed altering group offsets for the following partitions: " + partitionsFailed);
+                        "Failed altering consumer group offsets for the following partitions: " + partitionsFailed);
                 }
             }
             return null;
diff --git a/clients/src/main/java/org/apache/kafka/clients/admin/AlterStreamsGroupOffsetsOptions.java b/clients/src/main/java/org/apache/kafka/clients/admin/AlterStreamsGroupOffsetsOptions.java
deleted file mode 100644
index 6b65d5c01eb..00000000000
--- a/clients/src/main/java/org/apache/kafka/clients/admin/AlterStreamsGroupOffsetsOptions.java
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.kafka.clients.admin;
-
-import org.apache.kafka.common.annotation.InterfaceStability;
-
-
-/**
- * Options for the {@link Admin#alterStreamsGroupOffsets(String groupId, Map), AlterStreamsGroupOffsetsOptions)} call.
- * <p>
- * The API of this class is evolving, see {@link Admin} for details.
- */
-@InterfaceStability.Evolving
-public class AlterStreamsGroupOffsetsOptions extends AbstractOptions<AlterStreamsGroupOffsetsOptions> {
-}
diff --git a/clients/src/main/java/org/apache/kafka/clients/admin/AlterStreamsGroupOffsetsResult.java b/clients/src/main/java/org/apache/kafka/clients/admin/AlterStreamsGroupOffsetsResult.java
deleted file mode 100644
index 11813bf767f..00000000000
--- a/clients/src/main/java/org/apache/kafka/clients/admin/AlterStreamsGroupOffsetsResult.java
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.kafka.clients.admin;
-
-import org.apache.kafka.common.KafkaFuture;
-import org.apache.kafka.common.TopicPartition;
-import org.apache.kafka.common.annotation.InterfaceStability;
-
-import java.util.Map;
-
-/**
- * The result of the {@link AdminClient#alterStreamsGroupOffsets(String, Map)} call.
- *
- * The API of this class is evolving, see {@link AdminClient} for details.
- */
-@InterfaceStability.Evolving
-public class AlterStreamsGroupOffsetsResult {
-
-    private final AlterConsumerGroupOffsetsResult delegate;
-
-    AlterStreamsGroupOffsetsResult(final AlterConsumerGroupOffsetsResult delegate) {
-        this.delegate = delegate;
-    }
-
-    /**
-     * Return a future which can be used to check the result for a given partition.
-     */
-    public KafkaFuture<Void> partitionResult(final TopicPartition partition) {
-        return delegate.partitionResult(partition);
-    }
-
-    /**
-     * Return a future which succeeds if all the alter offsets succeed.
-     */
-    public KafkaFuture<Void> all() {
-        return delegate.all();
-    }
-}
diff --git a/clients/src/main/java/org/apache/kafka/clients/admin/DeleteStreamsGroupOffsetsOptions.java b/clients/src/main/java/org/apache/kafka/clients/admin/DeleteStreamsGroupOffsetsOptions.java
deleted file mode 100644
index 10d39075d8a..00000000000
--- a/clients/src/main/java/org/apache/kafka/clients/admin/DeleteStreamsGroupOffsetsOptions.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.kafka.clients.admin;
-
-import org.apache.kafka.common.annotation.InterfaceStability;
-
-import java.util.Set;
-
-/**
- * Options for the {@link Admin#deleteStreamsGroupOffsets(String, Set, DeleteStreamsGroupOffsetsOptions)} call.
- * <p>
- * The API of this class is evolving, see {@link Admin} for details.
- */
-@InterfaceStability.Evolving
-public class DeleteStreamsGroupOffsetsOptions extends AbstractOptions<DeleteStreamsGroupOffsetsOptions> {
-
-}
diff --git a/clients/src/main/java/org/apache/kafka/clients/admin/DeleteStreamsGroupOffsetsResult.java b/clients/src/main/java/org/apache/kafka/clients/admin/DeleteStreamsGroupOffsetsResult.java
deleted file mode 100644
index 4966ed063a8..00000000000
--- a/clients/src/main/java/org/apache/kafka/clients/admin/DeleteStreamsGroupOffsetsResult.java
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.kafka.clients.admin;
-
-import org.apache.kafka.common.KafkaFuture;
-import org.apache.kafka.common.TopicPartition;
-import org.apache.kafka.common.annotation.InterfaceStability;
-import org.apache.kafka.common.protocol.Errors;
-
-import java.util.Map;
-import java.util.Set;
-
-/**
- * The result of the {@link Admin#deleteStreamsGroupOffsets(String, Set, DeleteStreamsGroupOffsetsOptions)} call.
- * <p>
- * The API of this class is evolving, see {@link Admin} for details.
- */
-@InterfaceStability.Evolving
-public class DeleteStreamsGroupOffsetsResult {
-    private final DeleteConsumerGroupOffsetsResult delegate;
-
-    DeleteStreamsGroupOffsetsResult(KafkaFuture<Map<TopicPartition, Errors>> future, Set<TopicPartition> partitions) {
-        delegate = new DeleteConsumerGroupOffsetsResult(future, partitions);
-    }
-
-    DeleteStreamsGroupOffsetsResult(final DeleteConsumerGroupOffsetsResult delegate) {
-        this.delegate = delegate;
-    }
-
-    /**
-     * Return a future which succeeds only if all the deletions succeed.
-     */
-    public KafkaFuture<Void> all() {
-        return delegate.all();
-    }
-
-    /**
-     * Return a future which can be used to check the result for a given topic.
-     */
-    public KafkaFuture<Void> partitionResult(final TopicPartition topicPartition) {
-        return delegate.partitionResult(topicPartition);
-    }
-}
diff --git a/clients/src/main/java/org/apache/kafka/clients/admin/DeleteStreamsGroupsOptions.java b/clients/src/main/java/org/apache/kafka/clients/admin/DeleteStreamsGroupsOptions.java
deleted file mode 100644
index 6cd14797122..00000000000
--- a/clients/src/main/java/org/apache/kafka/clients/admin/DeleteStreamsGroupsOptions.java
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.kafka.clients.admin;
-
-import org.apache.kafka.common.annotation.InterfaceStability;
-
-import java.util.Collection;
-
-/**
- * Options for the {@link Admin#deleteStreamsGroups(Collection<String>, DeleteStreamsGroupsOptions)} call.
- * <p>
- * The API of this class is evolving, see {@link Admin} for details.
- */
-@InterfaceStability.Evolving
-public class DeleteStreamsGroupsOptions extends AbstractOptions<DeleteStreamsGroupsOptions> {
-}
diff --git a/clients/src/main/java/org/apache/kafka/clients/admin/DeleteStreamsGroupsResult.java b/clients/src/main/java/org/apache/kafka/clients/admin/DeleteStreamsGroupsResult.java
deleted file mode 100644
index 70debbbb519..00000000000
--- a/clients/src/main/java/org/apache/kafka/clients/admin/DeleteStreamsGroupsResult.java
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.kafka.clients.admin;
-
-import org.apache.kafka.common.KafkaFuture;
-import org.apache.kafka.common.annotation.InterfaceStability;
-
-import java.util.Collection;
-import java.util.Map;
-
-/**
- * The result of the {@link Admin#deleteStreamsGroups(Collection, DeleteStreamsGroupsOptions)} call.
- * <p>
- * The API of this class is evolving, see {@link Admin} for details.
- */
-@InterfaceStability.Evolving
-public class DeleteStreamsGroupsResult {
-
-    private final DeleteConsumerGroupsResult delegate;
-
-    DeleteStreamsGroupsResult(final Map<String, KafkaFuture<Void>> futures) {
-        delegate = new DeleteConsumerGroupsResult(futures);
-    }
-
-    DeleteStreamsGroupsResult(final DeleteConsumerGroupsResult delegate) {
-        this.delegate = delegate;
-    }
-
-    /**
-     * Return a future which succeeds only if all the deletions succeed.
-     */
-    public KafkaFuture<Void> all() {
-        return delegate.all();
-    }
-
-    /**
-     * Return a map from group id to futures which can be used to check the status of individual deletions.
-     */
-    public Map<String, KafkaFuture<Void>> deletedGroups() {
-        return delegate.deletedGroups();
-    }
-}
diff --git a/clients/src/main/java/org/apache/kafka/clients/admin/ForwardingAdmin.java b/clients/src/main/java/org/apache/kafka/clients/admin/ForwardingAdmin.java
index 8fb550ad542..ee2ac0942a9 100644
--- a/clients/src/main/java/org/apache/kafka/clients/admin/ForwardingAdmin.java
+++ b/clients/src/main/java/org/apache/kafka/clients/admin/ForwardingAdmin.java
@@ -168,31 +168,16 @@ public class ForwardingAdmin implements Admin {
         return delegate.listConsumerGroupOffsets(groupSpecs, options);
     }
 
-    @Override
-    public ListStreamsGroupOffsetsResult listStreamsGroupOffsets(Map<String, ListStreamsGroupOffsetsSpec> groupSpecs, ListStreamsGroupOffsetsOptions options) {
-        return delegate.listStreamsGroupOffsets(groupSpecs, options);
-    }
-
     @Override
     public DeleteConsumerGroupsResult deleteConsumerGroups(Collection<String> groupIds, DeleteConsumerGroupsOptions options) {
         return delegate.deleteConsumerGroups(groupIds, options);
     }
 
-    @Override
-    public DeleteStreamsGroupsResult deleteStreamsGroups(Collection<String> groupIds, DeleteStreamsGroupsOptions options) {
-        return delegate.deleteStreamsGroups(groupIds, options);
-    }
-
     @Override
     public DeleteConsumerGroupOffsetsResult deleteConsumerGroupOffsets(String groupId, Set<TopicPartition> partitions, DeleteConsumerGroupOffsetsOptions options) {
         return delegate.deleteConsumerGroupOffsets(groupId, partitions, options);
     }
 
-    @Override
-    public DeleteStreamsGroupOffsetsResult deleteStreamsGroupOffsets(String groupId, Set<TopicPartition> partitions, DeleteStreamsGroupOffsetsOptions options) {
-        return delegate.deleteStreamsGroupOffsets(groupId, partitions, options);
-    }
-
     @Override
     public ElectLeadersResult electLeaders(ElectionType electionType, Set<TopicPartition> partitions, ElectLeadersOptions options) {
         return delegate.electLeaders(electionType, partitions, options);
@@ -218,11 +203,6 @@ public class ForwardingAdmin implements Admin {
         return delegate.alterConsumerGroupOffsets(groupId, offsets, options);
     }
 
-    @Override
-    public AlterStreamsGroupOffsetsResult alterStreamsGroupOffsets(String groupId, Map<TopicPartition, OffsetAndMetadata> offsets, AlterStreamsGroupOffsetsOptions options) {
-        return delegate.alterStreamsGroupOffsets(groupId, offsets, options);
-    }
-
     @Override
     public ListOffsetsResult listOffsets(Map<TopicPartition, OffsetSpec> topicPartitionOffsets, ListOffsetsOptions options) {
         return delegate.listOffsets(topicPartitionOffsets, options);
diff --git a/clients/src/main/java/org/apache/kafka/clients/admin/KafkaAdminClient.java b/clients/src/main/java/org/apache/kafka/clients/admin/KafkaAdminClient.java
index af42f4421f4..8432ec754a0 100644
--- a/clients/src/main/java/org/apache/kafka/clients/admin/KafkaAdminClient.java
+++ b/clients/src/main/java/org/apache/kafka/clients/admin/KafkaAdminClient.java
@@ -3766,17 +3766,6 @@ public class KafkaAdminClient extends AdminClient {
         return new ListConsumerGroupOffsetsResult(future.all());
     }
 
-    @Override
-    public ListStreamsGroupOffsetsResult listStreamsGroupOffsets(Map<String, ListStreamsGroupOffsetsSpec> groupSpecs,
-                                                                   ListStreamsGroupOffsetsOptions options) {
-        Map<String, ListConsumerGroupOffsetsSpec> consumerGroupSpecs = groupSpecs.entrySet().stream()
-            .collect(Collectors.toMap(
-                Map.Entry::getKey,
-                entry -> new ListConsumerGroupOffsetsSpec().topicPartitions(entry.getValue().topicPartitions())
-            ));
-        return new ListStreamsGroupOffsetsResult(listConsumerGroupOffsets(consumerGroupSpecs, new ListConsumerGroupOffsetsOptions()));
-    }
-
     @Override
     public DeleteConsumerGroupsResult deleteConsumerGroups(Collection<String> groupIds, DeleteConsumerGroupsOptions options) {
         SimpleAdminApiFuture<CoordinatorKey, Void> future =
@@ -3787,11 +3776,6 @@ public class KafkaAdminClient extends AdminClient {
                 .collect(Collectors.toMap(entry -> entry.getKey().idValue, Map.Entry::getValue)));
     }
 
-    @Override
-    public DeleteStreamsGroupsResult deleteStreamsGroups(Collection<String> groupIds, DeleteStreamsGroupsOptions options) {
-        return new DeleteStreamsGroupsResult(deleteConsumerGroups(groupIds, new DeleteConsumerGroupsOptions()));
-    }
-
     @Override
     public DeleteConsumerGroupOffsetsResult deleteConsumerGroupOffsets(
             String groupId,
@@ -3804,14 +3788,6 @@ public class KafkaAdminClient extends AdminClient {
         return new DeleteConsumerGroupOffsetsResult(future.get(CoordinatorKey.byGroupId(groupId)), partitions);
     }
 
-    @Override
-    public DeleteStreamsGroupOffsetsResult deleteStreamsGroupOffsets(
-        String groupId,
-        Set<TopicPartition> partitions,
-        DeleteStreamsGroupOffsetsOptions options) {
-        return new DeleteStreamsGroupOffsetsResult(deleteConsumerGroupOffsets(groupId, partitions, new DeleteConsumerGroupOffsetsOptions()));
-    }
-
     @Override
     public DescribeShareGroupsResult describeShareGroups(final Collection<String> groupIds,
                                                          final DescribeShareGroupsOptions options) {
@@ -4243,15 +4219,6 @@ public class KafkaAdminClient extends AdminClient {
         return new AlterConsumerGroupOffsetsResult(future.get(CoordinatorKey.byGroupId(groupId)));
     }
 
-    @Override
-    public AlterStreamsGroupOffsetsResult alterStreamsGroupOffsets(
-        String groupId,
-        Map<TopicPartition, OffsetAndMetadata> offsets,
-        AlterStreamsGroupOffsetsOptions options
-    ) {
-        return new AlterStreamsGroupOffsetsResult(alterConsumerGroupOffsets(groupId, offsets, new AlterConsumerGroupOffsetsOptions()));
-    }
-
     @Override
     public ListOffsetsResult listOffsets(Map<TopicPartition, OffsetSpec> topicPartitionOffsets,
                                          ListOffsetsOptions options) {
diff --git a/clients/src/main/java/org/apache/kafka/clients/admin/ListStreamsGroupOffsetsOptions.java b/clients/src/main/java/org/apache/kafka/clients/admin/ListStreamsGroupOffsetsOptions.java
deleted file mode 100644
index 05caf1dee11..00000000000
--- a/clients/src/main/java/org/apache/kafka/clients/admin/ListStreamsGroupOffsetsOptions.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.kafka.clients.admin;
-
-import org.apache.kafka.common.annotation.InterfaceStability;
-
-
-/**
- * Options for {@link Admin#listStreamsGroupOffsets(Map, ListStreamsGroupOffsetsOptions)}.
- * <p>
- * The API of this class is evolving, see {@link Admin} for details.
- */
-@InterfaceStability.Evolving
-public class ListStreamsGroupOffsetsOptions extends AbstractOptions<ListStreamsGroupOffsetsOptions> {
-
-    private boolean requireStable = false;
-
-    /**
-     * Sets an optional requireStable flag.
-     */
-    public ListStreamsGroupOffsetsOptions requireStable(final boolean requireStable) {
-        this.requireStable = requireStable;
-        return this;
-    }
-
-    public boolean requireStable() {
-        return requireStable;
-    }
-}
diff --git a/clients/src/main/java/org/apache/kafka/clients/admin/ListStreamsGroupOffsetsResult.java b/clients/src/main/java/org/apache/kafka/clients/admin/ListStreamsGroupOffsetsResult.java
deleted file mode 100644
index d98179ee30f..00000000000
--- a/clients/src/main/java/org/apache/kafka/clients/admin/ListStreamsGroupOffsetsResult.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.kafka.clients.admin;
-
-import org.apache.kafka.clients.admin.internals.CoordinatorKey;
-import org.apache.kafka.clients.consumer.OffsetAndMetadata;
-import org.apache.kafka.common.KafkaFuture;
-import org.apache.kafka.common.TopicPartition;
-import org.apache.kafka.common.annotation.InterfaceStability;
-
-import java.util.Map;
-
-/**
- * The result of the {@link Admin#listStreamsGroupOffsets(Map, ListStreamsGroupOffsetsOptions)} call.
- * <p>
- * The API of this class is evolving, see {@link Admin} for details.
- */
-@InterfaceStability.Evolving
-public class ListStreamsGroupOffsetsResult {
-    private final ListConsumerGroupOffsetsResult delegate;
-
-    ListStreamsGroupOffsetsResult(final Map<CoordinatorKey, KafkaFuture<Map<TopicPartition, OffsetAndMetadata>>> futures) {
-        delegate = new ListConsumerGroupOffsetsResult(futures);
-    }
-
-    ListStreamsGroupOffsetsResult(final ListConsumerGroupOffsetsResult delegate) {
-        this.delegate = delegate;
-    }
-
-    /**
-     * Return a future which yields all Map<String, Map<TopicPartition, Long> objects, if requests for all the groups succeed.
-     */
-    public KafkaFuture<Map<String, Map<TopicPartition, OffsetAndMetadata>>> all() {
-        return delegate.all();
-    }
-
-    /**
-     * Return a future which yields a map of topic partitions to offsets for the specified group.
-     */
-    public KafkaFuture<Map<TopicPartition, OffsetAndMetadata>> partitionsToOffsetAndMetadata(String groupId) {
-        return delegate.partitionsToOffsetAndMetadata(groupId);
-    }
-}
diff --git a/clients/src/main/java/org/apache/kafka/clients/admin/ListStreamsGroupOffsetsSpec.java b/clients/src/main/java/org/apache/kafka/clients/admin/ListStreamsGroupOffsetsSpec.java
deleted file mode 100644
index c3fb9babb9a..00000000000
--- a/clients/src/main/java/org/apache/kafka/clients/admin/ListStreamsGroupOffsetsSpec.java
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.kafka.clients.admin;
-
-import org.apache.kafka.common.TopicPartition;
-import org.apache.kafka.common.annotation.InterfaceStability;
-
-import java.util.Collection;
-
-/**
- * Specification of Streams group offsets to list using {@link Admin#listStreamsGroupOffsets(Map, ListStreamsGroupOffsetsOptions)}.
- * <p>
- * The API of this class is evolving, see {@link Admin} for details.
- */
-@InterfaceStability.Evolving
-public class ListStreamsGroupOffsetsSpec {
-
-    private Collection<TopicPartition> topicPartitions;
-
-    /**
-     * Set the topic partitions whose offsets are to be listed for a Streams group.
-     */
-    ListStreamsGroupOffsetsSpec topicPartitions(Collection<TopicPartition> topicPartitions) {
-        this.topicPartitions = topicPartitions;
-        return this;
-    }
-
-    /**
-     * Returns the topic partitions whose offsets are to be listed for a Streams group.
-     */
-    Collection<TopicPartition> topicPartitions() {
-        return topicPartitions;
-    }
-}
diff --git a/clients/src/test/java/org/apache/kafka/clients/admin/KafkaAdminClientTest.java b/clients/src/test/java/org/apache/kafka/clients/admin/KafkaAdminClientTest.java
index 7b888e83962..6a60d53ccfe 100644
--- a/clients/src/test/java/org/apache/kafka/clients/admin/KafkaAdminClientTest.java
+++ b/clients/src/test/java/org/apache/kafka/clients/admin/KafkaAdminClientTest.java
@@ -302,6 +302,10 @@ import static java.util.Collections.singleton;
 import static java.util.Collections.singletonList;
 import static java.util.Collections.singletonMap;
 import static org.apache.kafka.clients.admin.KafkaAdminClient.DEFAULT_LEAVE_GROUP_REASON;
+import static org.apache.kafka.common.message.AlterPartitionReassignmentsResponseData.ReassignablePartitionResponse;
+import static org.apache.kafka.common.message.AlterPartitionReassignmentsResponseData.ReassignableTopicResponse;
+import static org.apache.kafka.common.message.ListPartitionReassignmentsResponseData.OngoingPartitionReassignment;
+import static org.apache.kafka.common.message.ListPartitionReassignmentsResponseData.OngoingTopicReassignment;
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
@@ -311,6 +315,7 @@ import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.ArgumentMatchers.anyString;
@@ -3606,29 +3611,6 @@ public class KafkaAdminClientTest {
         }
     }
 
-    @Test
-    public void testStreamsOffsetCommitNumRetries() throws Exception {
-        final Cluster cluster = mockCluster(3, 0);
-        final Time time = new MockTime();
-
-        try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster,
-            AdminClientConfig.RETRIES_CONFIG, "0")) {
-            env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-
-            final TopicPartition tp1 = new TopicPartition("foo", 0);
-
-            env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-            env.kafkaClient().prepareResponse(prepareOffsetCommitResponse(tp1, Errors.NOT_COORDINATOR));
-            env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-
-            Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
-            offsets.put(tp1, new OffsetAndMetadata(123L));
-            final AlterStreamsGroupOffsetsResult result = env.adminClient().alterStreamsGroupOffsets(GROUP_ID, offsets);
-
-            TestUtils.assertFutureThrows(TimeoutException.class, result.all());
-        }
-    }
-
     @Test
     public void testOffsetCommitWithMultipleErrors() throws Exception {
         final Cluster cluster = mockCluster(3, 0);
@@ -3662,39 +3644,6 @@ public class KafkaAdminClientTest {
         }
     }
 
-    @Test
-    public void testStreamsOffsetCommitWithMultipleErrors() throws Exception {
-        final Cluster cluster = mockCluster(3, 0);
-        final Time time = new MockTime();
-
-        try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster,
-            AdminClientConfig.RETRIES_CONFIG, "0")) {
-            env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-
-            final TopicPartition foo0 = new TopicPartition("foo", 0);
-            final TopicPartition foo1 = new TopicPartition("foo", 1);
-
-            env.kafkaClient().prepareResponse(
-                prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-
-            Map<TopicPartition, Errors> responseData = new HashMap<>();
-            responseData.put(foo0, Errors.NONE);
-            responseData.put(foo1, Errors.UNKNOWN_TOPIC_OR_PARTITION);
-            env.kafkaClient().prepareResponse(new OffsetCommitResponse(0, responseData));
-
-            Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
-            offsets.put(foo0, new OffsetAndMetadata(123L));
-            offsets.put(foo1, new OffsetAndMetadata(456L));
-            final AlterStreamsGroupOffsetsResult result = env.adminClient()
-                .alterStreamsGroupOffsets(GROUP_ID, offsets);
-
-            assertNull(result.partitionResult(foo0).get());
-            TestUtils.assertFutureThrows(UnknownTopicOrPartitionException.class, result.partitionResult(foo1));
-
-            TestUtils.assertFutureThrows(UnknownTopicOrPartitionException.class, result.all());
-        }
-    }
-
     @Test
     public void testOffsetCommitRetryBackoff() throws Exception {
         MockTime time = new MockTime();
@@ -3744,55 +3693,6 @@ public class KafkaAdminClientTest {
         }
     }
 
-    @Test
-    public void testStreamsOffsetCommitRetryBackoff() throws Exception {
-        MockTime time = new MockTime();
-        int retryBackoff = 100;
-
-        try (final AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time,
-            mockCluster(3, 0),
-            newStrMap(AdminClientConfig.RETRY_BACKOFF_MS_CONFIG, "" + retryBackoff))) {
-            MockClient mockClient = env.kafkaClient();
-
-            mockClient.setNodeApiVersions(NodeApiVersions.create());
-
-            AtomicLong firstAttemptTime = new AtomicLong(0);
-            AtomicLong secondAttemptTime = new AtomicLong(0);
-
-            final TopicPartition tp1 = new TopicPartition("foo", 0);
-
-            mockClient.prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-            mockClient.prepareResponse(body -> {
-                firstAttemptTime.set(time.milliseconds());
-                return true;
-            }, prepareOffsetCommitResponse(tp1, Errors.NOT_COORDINATOR));
-
-
-            mockClient.prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-            mockClient.prepareResponse(body -> {
-                secondAttemptTime.set(time.milliseconds());
-                return true;
-            }, prepareOffsetCommitResponse(tp1, Errors.NONE));
-
-
-            Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
-            offsets.put(tp1, new OffsetAndMetadata(123L));
-            final KafkaFuture<Void> future = env.adminClient().alterStreamsGroupOffsets(GROUP_ID, offsets).all();
-
-            TestUtils.waitForCondition(() -> mockClient.numAwaitingResponses() == 1, "Failed awaiting CommitOffsets first request failure");
-            TestUtils.waitForCondition(() -> ((KafkaAdminClient) env.adminClient()).numPendingCalls() == 1, "Failed to add retry CommitOffsets call on first failure");
-
-            long lowerBoundBackoffMs = (long) (retryBackoff * (1 - CommonClientConfigs.RETRY_BACKOFF_JITTER));
-            long upperBoundBackoffMs = (long) (retryBackoff * CommonClientConfigs.RETRY_BACKOFF_EXP_BASE * (1 + CommonClientConfigs.RETRY_BACKOFF_JITTER));
-            time.sleep(upperBoundBackoffMs);
-
-            future.get();
-
-            long actualRetryBackoff = secondAttemptTime.get() - firstAttemptTime.get();
-            assertEquals(retryBackoff, actualRetryBackoff, upperBoundBackoffMs - lowerBoundBackoffMs, "CommitOffsets retry did not await expected backoff");
-        }
-    }
-
     @Test
     public void testDescribeConsumerGroupNumRetries() throws Exception {
         final Cluster cluster = mockCluster(3, 0);
@@ -4591,23 +4491,6 @@ public class KafkaAdminClientTest {
         }
     }
 
-    @Test
-    public void testBatchedListStreamsGroupOffsets() throws Exception {
-        Cluster cluster = mockCluster(1, 0);
-        Time time = new MockTime();
-        Map<String, ListStreamsGroupOffsetsSpec> groupSpecs = batchedListStreamsGroupOffsetsSpec();
-
-        try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster, AdminClientConfig.RETRIES_CONFIG, "0")) {
-            env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-            env.kafkaClient().prepareResponse(prepareBatchedFindCoordinatorResponse(Errors.NONE, env.cluster().controller(), groupSpecs.keySet()));
-
-            ListStreamsGroupOffsetsResult result = env.adminClient().listStreamsGroupOffsets(groupSpecs, new ListStreamsGroupOffsetsOptions());
-            sendStreamsOffsetFetchResponse(env.kafkaClient(), groupSpecs, true, Errors.NONE);
-
-            verifyListStreamsOffsetsForMultipleGroups(groupSpecs, result);
-        }
-    }
-
     @Test
     public void testBatchedListConsumerGroupOffsetsWithNoFindCoordinatorBatching() throws Exception {
         Cluster cluster = mockCluster(1, 0);
@@ -4641,39 +4524,6 @@ public class KafkaAdminClientTest {
         }
     }
 
-    @Test
-    public void testBatchedListStreamsGroupOffsetsWithNoFindCoordinatorBatching() throws Exception {
-        Cluster cluster = mockCluster(1, 0);
-        Time time = new MockTime();
-        Map<String, ListStreamsGroupOffsetsSpec> groupSpecs = batchedListStreamsGroupOffsetsSpec();
-
-        ApiVersion findCoordinatorV3 = new ApiVersion()
-            .setApiKey(ApiKeys.FIND_COORDINATOR.id)
-            .setMinVersion((short) 0)
-            .setMaxVersion((short) 3);
-        ApiVersion offsetFetchV7 = new ApiVersion()
-            .setApiKey(ApiKeys.OFFSET_FETCH.id)
-            .setMinVersion((short) 0)
-            .setMaxVersion((short) 7);
-
-        try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster, AdminClientConfig.RETRY_BACKOFF_MS_CONFIG, "0")) {
-            env.kafkaClient().setNodeApiVersions(NodeApiVersions.create(asList(findCoordinatorV3, offsetFetchV7)));
-            env.kafkaClient().prepareResponse(prepareOldFindCoordinatorResponse(Errors.COORDINATOR_NOT_AVAILABLE, Node.noNode()));
-            env.kafkaClient().prepareResponse(prepareOldFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-            env.kafkaClient().prepareResponse(prepareOldFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-
-            ListStreamsGroupOffsetsResult result = env.adminClient().listStreamsGroupOffsets(groupSpecs);
-
-            // Fail the first request in order to ensure that the group is not batched when retried.
-            sendStreamsOffsetFetchResponse(env.kafkaClient(), groupSpecs, false, Errors.COORDINATOR_LOAD_IN_PROGRESS);
-
-            sendStreamsOffsetFetchResponse(env.kafkaClient(), groupSpecs, false, Errors.NONE);
-            sendStreamsOffsetFetchResponse(env.kafkaClient(), groupSpecs, false, Errors.NONE);
-
-            verifyListStreamsOffsetsForMultipleGroups(groupSpecs, result);
-        }
-    }
-
     @Test
     public void testBatchedListConsumerGroupOffsetsWithNoOffsetFetchBatching() throws Exception {
         Cluster cluster = mockCluster(1, 0);
@@ -4707,39 +4557,6 @@ public class KafkaAdminClientTest {
         }
     }
 
-    @Test
-    public void testBatchedListStreamsGroupOffsetsWithNoOffsetFetchBatching() throws Exception {
-        Cluster cluster = mockCluster(1, 0);
-        Time time = new MockTime();
-        Map<String, ListStreamsGroupOffsetsSpec> groupSpecs = batchedListStreamsGroupOffsetsSpec();
-
-        ApiVersion offsetFetchV7 = new ApiVersion()
-            .setApiKey(ApiKeys.OFFSET_FETCH.id)
-            .setMinVersion((short) 0)
-            .setMaxVersion((short) 7);
-
-        try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster, AdminClientConfig.RETRY_BACKOFF_MS_CONFIG, "0")) {
-            env.kafkaClient().setNodeApiVersions(NodeApiVersions.create(Collections.singleton(offsetFetchV7)));
-            env.kafkaClient().prepareResponse(prepareBatchedFindCoordinatorResponse(Errors.NONE, env.cluster().controller(), groupSpecs.keySet()));
-            // Prepare a response to force client to attempt batched request creation that throws
-            // NoBatchedOffsetFetchRequestException. This triggers creation of non-batched requests.
-            env.kafkaClient().prepareResponse(offsetFetchResponse(Errors.COORDINATOR_NOT_AVAILABLE, Collections.emptyMap()));
-
-            ListStreamsGroupOffsetsResult result = env.adminClient().listStreamsGroupOffsets(groupSpecs);
-
-            // The request handler attempts both FindCoordinator and OffsetFetch requests. This seems
-            // ok since we expect this scenario only during upgrades from versions < 3.0.0 where
-            // some upgraded brokers could handle batched FindCoordinator while non-upgraded coordinators
-            // rejected batched OffsetFetch requests.
-            sendFindCoordinatorResponse(env.kafkaClient(), env.cluster().controller());
-            sendFindCoordinatorResponse(env.kafkaClient(), env.cluster().controller());
-            sendStreamsOffsetFetchResponse(env.kafkaClient(), groupSpecs, false, Errors.NONE);
-            sendStreamsOffsetFetchResponse(env.kafkaClient(), groupSpecs, false, Errors.NONE);
-
-            verifyListStreamsOffsetsForMultipleGroups(groupSpecs, result);
-        }
-    }
-
     private Map<String, ListConsumerGroupOffsetsSpec> batchedListConsumerGroupOffsetsSpec() {
         Set<TopicPartition> groupAPartitions = Collections.singleton(new TopicPartition("A", 1));
         Set<TopicPartition> groupBPartitions =  Collections.singleton(new TopicPartition("B", 2));
@@ -4749,15 +4566,6 @@ public class KafkaAdminClientTest {
         return Utils.mkMap(Utils.mkEntry("groupA", groupASpec), Utils.mkEntry("groupB", groupBSpec));
     }
 
-    private Map<String, ListStreamsGroupOffsetsSpec> batchedListStreamsGroupOffsetsSpec() {
-        Set<TopicPartition> groupAPartitions = Collections.singleton(new TopicPartition("A", 1));
-        Set<TopicPartition> groupBPartitions =  Collections.singleton(new TopicPartition("B", 2));
-
-        ListStreamsGroupOffsetsSpec groupASpec = new ListStreamsGroupOffsetsSpec().topicPartitions(groupAPartitions);
-        ListStreamsGroupOffsetsSpec groupBSpec = new ListStreamsGroupOffsetsSpec().topicPartitions(groupBPartitions);
-        return Utils.mkMap(Utils.mkEntry("groupA", groupASpec), Utils.mkEntry("groupB", groupBSpec));
-    }
-
     private void waitForRequest(MockClient mockClient, ApiKeys apiKeys) throws Exception {
         TestUtils.waitForCondition(() -> {
             ClientRequest clientRequest = mockClient.requests().peek();
@@ -4795,28 +4603,6 @@ public class KafkaAdminClientTest {
             mockClient.respond(new OffsetFetchResponse(THROTTLE, errors, results));
     }
 
-    private void sendStreamsOffsetFetchResponse(MockClient mockClient, Map<String, ListStreamsGroupOffsetsSpec> groupSpecs, boolean batched, Errors error) throws Exception {
-        waitForRequest(mockClient, ApiKeys.OFFSET_FETCH);
-
-        ClientRequest clientRequest = mockClient.requests().peek();
-        OffsetFetchRequestData data = ((OffsetFetchRequest.Builder) clientRequest.requestBuilder()).data;
-        Map<String, Map<TopicPartition, PartitionData>> results = new HashMap<>();
-        Map<String, Errors> errors = new HashMap<>();
-        data.groups().forEach(group -> {
-            Map<TopicPartition, PartitionData> partitionResults = new HashMap<>();
-            for (TopicPartition tp : groupSpecs.get(group.groupId()).topicPartitions()) {
-                partitionResults.put(tp, new PartitionData(10, Optional.empty(), "", Errors.NONE));
-            }
-            results.put(group.groupId(), partitionResults);
-            errors.put(group.groupId(), error);
-        });
-        if (!batched) {
-            assertEquals(1, data.groups().size());
-            mockClient.respond(new OffsetFetchResponse(THROTTLE, error, results.values().iterator().next()));
-        } else
-            mockClient.respond(new OffsetFetchResponse(THROTTLE, errors, results));
-    }
-
     private void verifyListOffsetsForMultipleGroups(Map<String, ListConsumerGroupOffsetsSpec> groupSpecs,
                                                     ListConsumerGroupOffsetsResult result) throws Exception {
         assertEquals(groupSpecs.size(), result.all().get(10, TimeUnit.SECONDS).size());
@@ -4826,15 +4612,6 @@ public class KafkaAdminClientTest {
         }
     }
 
-    private void verifyListStreamsOffsetsForMultipleGroups(Map<String, ListStreamsGroupOffsetsSpec> groupSpecs,
-                                                           ListStreamsGroupOffsetsResult result) throws Exception {
-        assertEquals(groupSpecs.size(), result.all().get(10, TimeUnit.SECONDS).size());
-        for (Map.Entry<String, ListStreamsGroupOffsetsSpec> entry : groupSpecs.entrySet()) {
-            assertEquals(entry.getValue().topicPartitions(),
-                result.partitionsToOffsetAndMetadata(entry.getKey()).get().keySet());
-        }
-    }
-
     @Test
     public void testDeleteConsumerGroupsNumRetries() throws Exception {
         final Cluster cluster = mockCluster(3, 0);
@@ -4862,33 +4639,6 @@ public class KafkaAdminClientTest {
         }
     }
 
-    @Test
-    public void testDeleteStreamsGroupsNumRetries() throws Exception {
-        final Cluster cluster = mockCluster(3, 0);
-        final Time time = new MockTime();
-        final List<String> groupIds = singletonList("groupId");
-
-        try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster,
-            AdminClientConfig.RETRIES_CONFIG, "0")) {
-            env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-
-            env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-            final DeletableGroupResultCollection validResponse = new DeletableGroupResultCollection();
-            validResponse.add(new DeletableGroupResult()
-                .setGroupId("groupId")
-                .setErrorCode(Errors.NOT_COORDINATOR.code()));
-            env.kafkaClient().prepareResponse(new DeleteGroupsResponse(
-                new DeleteGroupsResponseData()
-                    .setResults(validResponse)
-            ));
-            env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-
-            final DeleteStreamsGroupsResult result = env.adminClient().deleteStreamsGroups(groupIds);
-
-            TestUtils.assertFutureThrows(TimeoutException.class, result.all());
-        }
-    }
-
     @Test
     public void testDeleteConsumerGroupsRetryBackoff() throws Exception {
         MockTime time = new MockTime();
@@ -4946,63 +4696,6 @@ public class KafkaAdminClientTest {
         }
     }
 
-    @Test
-    public void testDeleteStreamsGroupsRetryBackoff() throws Exception {
-        MockTime time = new MockTime();
-        int retryBackoff = 100;
-        final List<String> groupIds = singletonList(GROUP_ID);
-
-        try (final AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time,
-            mockCluster(3, 0),
-            newStrMap(AdminClientConfig.RETRY_BACKOFF_MS_CONFIG, "" + retryBackoff))) {
-            MockClient mockClient = env.kafkaClient();
-
-            mockClient.setNodeApiVersions(NodeApiVersions.create());
-
-            AtomicLong firstAttemptTime = new AtomicLong(0);
-            AtomicLong secondAttemptTime = new AtomicLong(0);
-
-            mockClient.prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-
-            DeletableGroupResultCollection validResponse = new DeletableGroupResultCollection();
-            validResponse.add(new DeletableGroupResult()
-                .setGroupId(GROUP_ID)
-                .setErrorCode(Errors.NOT_COORDINATOR.code()));
-
-
-            mockClient.prepareResponse(body -> {
-                firstAttemptTime.set(time.milliseconds());
-                return true;
-            }, new DeleteGroupsResponse(new DeleteGroupsResponseData().setResults(validResponse)));
-
-            mockClient.prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-
-            validResponse = new DeletableGroupResultCollection();
-            validResponse.add(new DeletableGroupResult()
-                .setGroupId(GROUP_ID)
-                .setErrorCode(Errors.NONE.code()));
-
-            mockClient.prepareResponse(body -> {
-                secondAttemptTime.set(time.milliseconds());
-                return true;
-            }, new DeleteGroupsResponse(new DeleteGroupsResponseData().setResults(validResponse)));
-
-            final KafkaFuture<Void> future = env.adminClient().deleteStreamsGroups(groupIds).all();
-
-            TestUtils.waitForCondition(() -> mockClient.numAwaitingResponses() == 1, "Failed awaiting DeleteStreamsGroups first request failure");
-            TestUtils.waitForCondition(() -> ((KafkaAdminClient) env.adminClient()).numPendingCalls() == 1, "Failed to add retry DeleteStreamsGroups call on first failure");
-
-            long lowerBoundBackoffMs = (long) (retryBackoff * (1 - CommonClientConfigs.RETRY_BACKOFF_JITTER));
-            long upperBoundBackoffMs = (long) (retryBackoff * CommonClientConfigs.RETRY_BACKOFF_EXP_BASE * (1 + CommonClientConfigs.RETRY_BACKOFF_JITTER));
-            time.sleep(upperBoundBackoffMs);
-
-            future.get();
-
-            long actualRetryBackoff = secondAttemptTime.get() - firstAttemptTime.get();
-            assertEquals(retryBackoff, actualRetryBackoff, upperBoundBackoffMs - lowerBoundBackoffMs, "DeleteConsumerGroups retry did not await expected backoff!");
-        }
-    }
-
     @Test
     public void testDeleteConsumerGroupsWithOlderBroker() throws Exception {
         final List<String> groupIds = singletonList("groupId");
@@ -5099,102 +4792,6 @@ public class KafkaAdminClientTest {
         }
     }
 
-    @Test
-    public void testDeleteStreamsGroupsWithOlderBroker() throws Exception {
-        final List<String> groupIds = singletonList("groupId");
-        ApiVersion findCoordinatorV3 = new ApiVersion()
-            .setApiKey(ApiKeys.FIND_COORDINATOR.id)
-            .setMinVersion((short) 0)
-            .setMaxVersion((short) 3);
-        ApiVersion describeGroups = new ApiVersion()
-            .setApiKey(ApiKeys.DESCRIBE_GROUPS.id)
-            .setMinVersion((short) 0)
-            .setMaxVersion(ApiKeys.DELETE_GROUPS.latestVersion());
-
-        try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
-            env.kafkaClient().setNodeApiVersions(NodeApiVersions.create(asList(findCoordinatorV3, describeGroups)));
-
-            // Retriable FindCoordinatorResponse errors should be retried
-            env.kafkaClient().prepareResponse(prepareOldFindCoordinatorResponse(Errors.COORDINATOR_NOT_AVAILABLE,  Node.noNode()));
-            env.kafkaClient().prepareResponse(prepareOldFindCoordinatorResponse(Errors.COORDINATOR_LOAD_IN_PROGRESS, Node.noNode()));
-
-            env.kafkaClient().prepareResponse(prepareOldFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-
-            final DeletableGroupResultCollection validResponse = new DeletableGroupResultCollection();
-            validResponse.add(new DeletableGroupResult()
-                .setGroupId("groupId")
-                .setErrorCode(Errors.NONE.code()));
-            env.kafkaClient().prepareResponse(new DeleteGroupsResponse(
-                new DeleteGroupsResponseData()
-                    .setResults(validResponse)
-            ));
-
-            final DeleteStreamsGroupsResult result = env.adminClient().deleteStreamsGroups(groupIds);
-
-            final KafkaFuture<Void> results = result.deletedGroups().get("groupId");
-            assertNull(results.get());
-
-            // should throw error for non-retriable errors
-            env.kafkaClient().prepareResponse(
-                prepareOldFindCoordinatorResponse(Errors.GROUP_AUTHORIZATION_FAILED, Node.noNode()));
-
-            DeleteStreamsGroupsResult errorResult = env.adminClient().deleteStreamsGroups(groupIds);
-            TestUtils.assertFutureThrows(GroupAuthorizationException.class, errorResult.deletedGroups().get("groupId"));
-
-            // Retriable errors should be retried
-            env.kafkaClient().prepareResponse(
-                prepareOldFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-
-            final DeletableGroupResultCollection errorResponse = new DeletableGroupResultCollection();
-            errorResponse.add(new DeletableGroupResult()
-                .setGroupId("groupId")
-                .setErrorCode(Errors.COORDINATOR_LOAD_IN_PROGRESS.code())
-            );
-            env.kafkaClient().prepareResponse(new DeleteGroupsResponse(
-                new DeleteGroupsResponseData()
-                    .setResults(errorResponse)));
-
-            /*
-             * We need to return two responses here, one for NOT_COORDINATOR call when calling delete a consumer group
-             * api using coordinator that has moved. This will retry whole operation. So we need to again respond with a
-             * FindCoordinatorResponse.
-             *
-             * And the same reason for the following COORDINATOR_NOT_AVAILABLE error response
-             */
-
-            DeletableGroupResultCollection coordinatorMoved = new DeletableGroupResultCollection();
-            coordinatorMoved.add(new DeletableGroupResult()
-                .setGroupId("groupId")
-                .setErrorCode(Errors.NOT_COORDINATOR.code())
-            );
-
-            env.kafkaClient().prepareResponse(new DeleteGroupsResponse(
-                new DeleteGroupsResponseData()
-                    .setResults(coordinatorMoved)));
-            env.kafkaClient().prepareResponse(prepareOldFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-
-            coordinatorMoved = new DeletableGroupResultCollection();
-            coordinatorMoved.add(new DeletableGroupResult()
-                .setGroupId("groupId")
-                .setErrorCode(Errors.COORDINATOR_NOT_AVAILABLE.code())
-            );
-
-            env.kafkaClient().prepareResponse(new DeleteGroupsResponse(
-                new DeleteGroupsResponseData()
-                    .setResults(coordinatorMoved)));
-            env.kafkaClient().prepareResponse(prepareOldFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-
-            env.kafkaClient().prepareResponse(new DeleteGroupsResponse(
-                new DeleteGroupsResponseData()
-                    .setResults(validResponse)));
-
-            errorResult = env.adminClient().deleteStreamsGroups(groupIds);
-
-            final KafkaFuture<Void> errorResults = errorResult.deletedGroups().get("groupId");
-            assertNull(errorResults.get());
-        }
-    }
-
     @Test
     public void testDeleteMultipleConsumerGroupsWithOlderBroker() throws Exception {
         final List<String> groupIds = asList("group1", "group2");
@@ -5243,54 +4840,6 @@ public class KafkaAdminClientTest {
         }
     }
 
-    @Test
-    public void testDeleteMultipleStreamsGroupsWithOlderBroker() throws Exception {
-        final List<String> groupIds = asList("group1", "group2");
-        ApiVersion findCoordinatorV3 = new ApiVersion()
-            .setApiKey(ApiKeys.FIND_COORDINATOR.id)
-            .setMinVersion((short) 0)
-            .setMaxVersion((short) 3);
-        ApiVersion describeGroups = new ApiVersion()
-            .setApiKey(ApiKeys.DESCRIBE_GROUPS.id)
-            .setMinVersion((short) 0)
-            .setMaxVersion(ApiKeys.DELETE_GROUPS.latestVersion());
-
-        try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
-            env.kafkaClient().setNodeApiVersions(
-                NodeApiVersions.create(asList(findCoordinatorV3, describeGroups)));
-
-            // Dummy response for MockClient to handle the UnsupportedVersionException correctly to switch from batched to un-batched
-            env.kafkaClient().prepareResponse(null);
-            // Retriable FindCoordinatorResponse errors should be retried
-            for (int i = 0; i < groupIds.size(); i++) {
-                env.kafkaClient().prepareResponse(
-                    prepareOldFindCoordinatorResponse(Errors.COORDINATOR_NOT_AVAILABLE, Node.noNode()));
-            }
-            for (int i = 0; i < groupIds.size(); i++) {
-                env.kafkaClient().prepareResponse(
-                    prepareOldFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-            }
-
-            final DeletableGroupResultCollection validResponse = new DeletableGroupResultCollection();
-            validResponse.add(new DeletableGroupResult()
-                .setGroupId("group1")
-                .setErrorCode(Errors.NONE.code()));
-            validResponse.add(new DeletableGroupResult()
-                .setGroupId("group2")
-                .setErrorCode(Errors.NONE.code()));
-            env.kafkaClient().prepareResponse(new DeleteGroupsResponse(
-                new DeleteGroupsResponseData()
-                    .setResults(validResponse)
-            ));
-
-            final DeleteStreamsGroupsResult result = env.adminClient()
-                .deleteStreamsGroups(groupIds);
-
-            final KafkaFuture<Void> results = result.deletedGroups().get("group1");
-            assertNull(results.get(5, TimeUnit.SECONDS));
-        }
-    }
-
     @Test
     public void testDeleteConsumerGroupOffsetsNumRetries() throws Exception {
         final Cluster cluster = mockCluster(3, 0);
@@ -5313,28 +4862,6 @@ public class KafkaAdminClientTest {
         }
     }
 
-    @Test
-    public void testDeleteStreamsGroupOffsetsNumRetries() throws Exception {
-        final Cluster cluster = mockCluster(3, 0);
-        final Time time = new MockTime();
-
-        try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time, cluster,
-            AdminClientConfig.RETRIES_CONFIG, "0")) {
-            final TopicPartition tp1 = new TopicPartition("foo", 0);
-
-            env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-
-            env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-            env.kafkaClient().prepareResponse(prepareOffsetDeleteResponse(Errors.NOT_COORDINATOR));
-            env.kafkaClient().prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-
-            final DeleteStreamsGroupOffsetsResult result = env.adminClient()
-                .deleteStreamsGroupOffsets(GROUP_ID, Stream.of(tp1).collect(Collectors.toSet()));
-
-            TestUtils.assertFutureThrows(TimeoutException.class, result.all());
-        }
-    }
-
     @Test
     public void testDeleteConsumerGroupOffsetsRetryBackoff() throws Exception {
         MockTime time = new MockTime();
@@ -5383,54 +4910,6 @@ public class KafkaAdminClientTest {
         }
     }
 
-    @Test
-    public void testDeleteStreamsGroupOffsetsRetryBackoff() throws Exception {
-        MockTime time = new MockTime();
-        int retryBackoff = 100;
-
-        try (final AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(time,
-            mockCluster(3, 0),
-            newStrMap(AdminClientConfig.RETRY_BACKOFF_MS_CONFIG, "" + retryBackoff))) {
-            MockClient mockClient = env.kafkaClient();
-
-            mockClient.setNodeApiVersions(NodeApiVersions.create());
-
-            AtomicLong firstAttemptTime = new AtomicLong(0);
-            AtomicLong secondAttemptTime = new AtomicLong(0);
-
-            final TopicPartition tp1 = new TopicPartition("foo", 0);
-
-            mockClient.prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-
-            mockClient.prepareResponse(body -> {
-                firstAttemptTime.set(time.milliseconds());
-                return true;
-            }, prepareOffsetDeleteResponse(Errors.NOT_COORDINATOR));
-
-
-            mockClient.prepareResponse(prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-
-            mockClient.prepareResponse(body -> {
-                secondAttemptTime.set(time.milliseconds());
-                return true;
-            }, prepareOffsetDeleteResponse("foo", 0, Errors.NONE));
-
-            final KafkaFuture<Void> future = env.adminClient().deleteStreamsGroupOffsets(GROUP_ID, Stream.of(tp1).collect(Collectors.toSet())).all();
-
-            TestUtils.waitForCondition(() -> mockClient.numAwaitingResponses() == 1, "Failed awaiting DeleteStreamsGroupOffsets first request failure");
-            TestUtils.waitForCondition(() -> ((KafkaAdminClient) env.adminClient()).numPendingCalls() == 1, "Failed to add retry DeleteStreamsGroupOffsets call on first failure");
-
-            long lowerBoundBackoffMs = (long) (retryBackoff * (1 - CommonClientConfigs.RETRY_BACKOFF_JITTER));
-            long upperBoundBackoffMs = (long) (retryBackoff * CommonClientConfigs.RETRY_BACKOFF_EXP_BASE * (1 + CommonClientConfigs.RETRY_BACKOFF_JITTER));
-            time.sleep(upperBoundBackoffMs);
-
-            future.get();
-
-            long actualRetryBackoff = secondAttemptTime.get() - firstAttemptTime.get();
-            assertEquals(retryBackoff, actualRetryBackoff, upperBoundBackoffMs - lowerBoundBackoffMs, "DeleteStreamsGroupOffsets retry did not await expected backoff!");
-        }
-    }
-
     @Test
     public void testDeleteConsumerGroupOffsets() throws Exception {
         // Happy path
@@ -5458,60 +4937,15 @@ public class KafkaAdminClientTest {
                         new OffsetDeleteResponseTopic()
                             .setName("bar")
                             .setPartitions(new OffsetDeleteResponsePartitionCollection(Collections.singletonList(
-                                new OffsetDeleteResponsePartition()
-                                    .setPartitionIndex(0)
-                                    .setErrorCode(Errors.GROUP_SUBSCRIBED_TO_TOPIC.code())
-                            ).iterator()))
-                    ).collect(Collectors.toList()).iterator()))
-                )
-            );
-
-            final DeleteConsumerGroupOffsetsResult errorResult = env.adminClient().deleteConsumerGroupOffsets(
-                GROUP_ID, Stream.of(tp1, tp2).collect(Collectors.toSet()));
-
-            assertNull(errorResult.partitionResult(tp1).get());
-            TestUtils.assertFutureThrows(GroupSubscribedToTopicException.class, errorResult.all());
-            TestUtils.assertFutureThrows(GroupSubscribedToTopicException.class, errorResult.partitionResult(tp2));
-            assertThrows(IllegalArgumentException.class, () -> errorResult.partitionResult(tp3));
-        }
-    }
-
-    @Test
-    public void testDeleteStreamsGroupOffsets() throws Exception {
-        // Happy path
-
-        final TopicPartition tp1 = new TopicPartition("foo", 0);
-        final TopicPartition tp2 = new TopicPartition("bar", 0);
-        final TopicPartition tp3 = new TopicPartition("foobar", 0);
-
-        try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
-            env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-
-            env.kafkaClient().prepareResponse(
-                prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-
-            env.kafkaClient().prepareResponse(new OffsetDeleteResponse(
-                    new OffsetDeleteResponseData()
-                        .setTopics(new OffsetDeleteResponseTopicCollection(Stream.of(
-                            new OffsetDeleteResponseTopic()
-                                .setName("foo")
-                                .setPartitions(new OffsetDeleteResponsePartitionCollection(Collections.singletonList(
-                                    new OffsetDeleteResponsePartition()
-                                        .setPartitionIndex(0)
-                                        .setErrorCode(Errors.NONE.code())
-                                ).iterator())),
-                            new OffsetDeleteResponseTopic()
-                                .setName("bar")
-                                .setPartitions(new OffsetDeleteResponsePartitionCollection(Collections.singletonList(
-                                    new OffsetDeleteResponsePartition()
-                                        .setPartitionIndex(0)
-                                        .setErrorCode(Errors.GROUP_SUBSCRIBED_TO_TOPIC.code())
-                                ).iterator()))
-                        ).collect(Collectors.toList()).iterator()))
+                                new OffsetDeleteResponsePartition()
+                                    .setPartitionIndex(0)
+                                    .setErrorCode(Errors.GROUP_SUBSCRIBED_TO_TOPIC.code())
+                            ).iterator()))
+                    ).collect(Collectors.toList()).iterator()))
                 )
             );
 
-            final DeleteStreamsGroupOffsetsResult errorResult = env.adminClient().deleteStreamsGroupOffsets(
+            final DeleteConsumerGroupOffsetsResult errorResult = env.adminClient().deleteConsumerGroupOffsets(
                 GROUP_ID, Stream.of(tp1, tp2).collect(Collectors.toSet()));
 
             assertNull(errorResult.partitionResult(tp1).get());
@@ -5566,52 +5000,6 @@ public class KafkaAdminClientTest {
         }
     }
 
-    @Test
-    public void testDeleteStreamsGroupOffsetsRetriableErrors() throws Exception {
-        // Retriable errors should be retried
-
-        final TopicPartition tp1 = new TopicPartition("foo", 0);
-
-        try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
-            env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-
-            env.kafkaClient().prepareResponse(
-                prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-
-            env.kafkaClient().prepareResponse(
-                prepareOffsetDeleteResponse(Errors.COORDINATOR_LOAD_IN_PROGRESS));
-
-            /*
-             * We need to return two responses here, one for NOT_COORDINATOR call when calling delete a consumer group
-             * api using coordinator that has moved. This will retry whole operation. So we need to again respond with a
-             * FindCoordinatorResponse.
-             *
-             * And the same reason for the following COORDINATOR_NOT_AVAILABLE error response
-             */
-            env.kafkaClient().prepareResponse(
-                prepareOffsetDeleteResponse(Errors.NOT_COORDINATOR));
-
-            env.kafkaClient().prepareResponse(
-                prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-
-            env.kafkaClient().prepareResponse(
-                prepareOffsetDeleteResponse(Errors.COORDINATOR_NOT_AVAILABLE));
-
-            env.kafkaClient().prepareResponse(
-                prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-
-            env.kafkaClient().prepareResponse(
-                prepareOffsetDeleteResponse("foo", 0, Errors.NONE));
-
-            final DeleteStreamsGroupOffsetsResult errorResult1 = env.adminClient()
-                .deleteStreamsGroupOffsets(GROUP_ID, Stream.of(tp1).collect(Collectors.toSet()));
-
-            assertNull(errorResult1.all().get());
-            assertNull(errorResult1.partitionResult(tp1).get());
-        }
-    }
-
-
     @Test
     public void testDeleteConsumerGroupOffsetsNonRetriableErrors() throws Exception {
         // Non-retriable errors throw an exception
@@ -5639,33 +5027,6 @@ public class KafkaAdminClientTest {
         }
     }
 
-    @Test
-    public void testDeleteStreamsGroupOffsetsNonRetriableErrors() throws Exception {
-        // Non-retriable errors throw an exception
-
-        final TopicPartition tp1 = new TopicPartition("foo", 0);
-        final List<Errors> nonRetriableErrors = asList(
-            Errors.GROUP_AUTHORIZATION_FAILED, Errors.INVALID_GROUP_ID, Errors.GROUP_ID_NOT_FOUND);
-
-        try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
-            env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-
-            for (Errors error : nonRetriableErrors) {
-                env.kafkaClient().prepareResponse(
-                    prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-
-                env.kafkaClient().prepareResponse(
-                    prepareOffsetDeleteResponse(error));
-
-                DeleteStreamsGroupOffsetsResult errorResult = env.adminClient()
-                    .deleteStreamsGroupOffsets(GROUP_ID, Stream.of(tp1).collect(Collectors.toSet()));
-
-                TestUtils.assertFutureThrows(error.exception().getClass(), errorResult.all());
-                TestUtils.assertFutureThrows(error.exception().getClass(), errorResult.partitionResult(tp1));
-            }
-        }
-    }
-
     @Test
     public void testDeleteConsumerGroupOffsetsFindCoordinatorRetriableErrors() throws Exception {
         // Retriable FindCoordinatorResponse errors should be retried
@@ -5694,34 +5055,6 @@ public class KafkaAdminClientTest {
         }
     }
 
-    @Test
-    public void testDeleteStreamsGroupOffsetsFindCoordinatorRetriableErrors() throws Exception {
-        // Retriable FindCoordinatorResponse errors should be retried
-
-        final TopicPartition tp1 = new TopicPartition("foo", 0);
-
-        try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
-            env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-
-            env.kafkaClient().prepareResponse(
-                prepareFindCoordinatorResponse(Errors.COORDINATOR_NOT_AVAILABLE, Node.noNode()));
-            env.kafkaClient().prepareResponse(
-                prepareFindCoordinatorResponse(Errors.COORDINATOR_LOAD_IN_PROGRESS, Node.noNode()));
-
-            env.kafkaClient().prepareResponse(
-                prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-
-            env.kafkaClient().prepareResponse(
-                prepareOffsetDeleteResponse("foo", 0, Errors.NONE));
-
-            final DeleteStreamsGroupOffsetsResult result = env.adminClient()
-                .deleteStreamsGroupOffsets(GROUP_ID, Stream.of(tp1).collect(Collectors.toSet()));
-
-            assertNull(result.all().get());
-            assertNull(result.partitionResult(tp1).get());
-        }
-    }
-
     @Test
     public void testDeleteConsumerGroupOffsetsFindCoordinatorNonRetriableErrors() throws Exception {
         // Non-retriable FindCoordinatorResponse errors throw an exception
@@ -5742,26 +5075,6 @@ public class KafkaAdminClientTest {
         }
     }
 
-    @Test
-    public void testDeleteStreamsGroupOffsetsFindCoordinatorNonRetriableErrors() throws Exception {
-        // Non-retriable FindCoordinatorResponse errors throw an exception
-
-        final TopicPartition tp1 = new TopicPartition("foo", 0);
-
-        try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
-            env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-
-            env.kafkaClient().prepareResponse(
-                prepareFindCoordinatorResponse(Errors.GROUP_AUTHORIZATION_FAILED,  Node.noNode()));
-
-            final DeleteStreamsGroupOffsetsResult errorResult = env.adminClient()
-                .deleteStreamsGroupOffsets(GROUP_ID, Stream.of(tp1).collect(Collectors.toSet()));
-
-            TestUtils.assertFutureThrows(GroupAuthorizationException.class, errorResult.all());
-            TestUtils.assertFutureThrows(GroupAuthorizationException.class, errorResult.partitionResult(tp1));
-        }
-    }
-
     @Test
     public void testDescribeShareGroups() throws Exception {
         try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
@@ -7081,38 +6394,6 @@ public class KafkaAdminClientTest {
         }
     }
 
-    @Test
-    public void testAlterStreamsGroupOffsets() throws Exception {
-        // Happy path
-
-        final TopicPartition tp1 = new TopicPartition("foo", 0);
-        final TopicPartition tp2 = new TopicPartition("bar", 0);
-        final TopicPartition tp3 = new TopicPartition("foobar", 0);
-
-        try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
-            env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-
-            env.kafkaClient().prepareResponse(
-                prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-
-            Map<TopicPartition, Errors> responseData = new HashMap<>();
-            responseData.put(tp1, Errors.NONE);
-            responseData.put(tp2, Errors.NONE);
-            env.kafkaClient().prepareResponse(new OffsetCommitResponse(0, responseData));
-
-            Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
-            offsets.put(tp1, new OffsetAndMetadata(123L));
-            offsets.put(tp2, new OffsetAndMetadata(456L));
-            final AlterStreamsGroupOffsetsResult result = env.adminClient().alterStreamsGroupOffsets(
-                GROUP_ID, offsets);
-
-            assertNull(result.all().get());
-            assertNull(result.partitionResult(tp1).get());
-            assertNull(result.partitionResult(tp2).get());
-            TestUtils.assertFutureThrows(IllegalArgumentException.class, result.partitionResult(tp3));
-        }
-    }
-
     @Test
     public void testAlterConsumerGroupOffsetsRetriableErrors() throws Exception {
         // Retriable errors should be retried
@@ -7156,49 +6437,6 @@ public class KafkaAdminClientTest {
         }
     }
 
-    @Test
-    public void testAlterStreamsGroupOffsetsRetriableErrors() throws Exception {
-        // Retriable errors should be retried
-
-        final TopicPartition tp1 = new TopicPartition("foo", 0);
-
-        try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
-            env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-
-            env.kafkaClient().prepareResponse(
-                prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-
-            env.kafkaClient().prepareResponse(
-                prepareOffsetCommitResponse(tp1, Errors.COORDINATOR_NOT_AVAILABLE));
-
-            env.kafkaClient().prepareResponse(
-                prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-
-            env.kafkaClient().prepareResponse(
-                prepareOffsetCommitResponse(tp1, Errors.COORDINATOR_LOAD_IN_PROGRESS));
-
-            env.kafkaClient().prepareResponse(
-                prepareOffsetCommitResponse(tp1, Errors.NOT_COORDINATOR));
-
-            env.kafkaClient().prepareResponse(
-                prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-
-            env.kafkaClient().prepareResponse(
-                prepareOffsetCommitResponse(tp1, Errors.REBALANCE_IN_PROGRESS));
-
-            env.kafkaClient().prepareResponse(
-                prepareOffsetCommitResponse(tp1, Errors.NONE));
-
-            Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
-            offsets.put(tp1, new OffsetAndMetadata(123L));
-            final AlterStreamsGroupOffsetsResult result1 = env.adminClient()
-                .alterStreamsGroupOffsets(GROUP_ID, offsets);
-
-            assertNull(result1.all().get());
-            assertNull(result1.partitionResult(tp1).get());
-        }
-    }
-
     @Test
     public void testAlterConsumerGroupOffsetsNonRetriableErrors() throws Exception {
         // Non-retriable errors throw an exception
@@ -7227,34 +6465,6 @@ public class KafkaAdminClientTest {
         }
     }
 
-    @Test
-    public void testAlterStreamsGroupOffsetsNonRetriableErrors() throws Exception {
-        // Non-retriable errors throw an exception
-
-        final TopicPartition tp1 = new TopicPartition("foo", 0);
-        final List<Errors> nonRetriableErrors = asList(
-            Errors.GROUP_AUTHORIZATION_FAILED, Errors.INVALID_GROUP_ID, Errors.GROUP_ID_NOT_FOUND, Errors.STALE_MEMBER_EPOCH);
-
-        try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
-            env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-
-            for (Errors error : nonRetriableErrors) {
-                env.kafkaClient().prepareResponse(
-                    prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-
-                env.kafkaClient().prepareResponse(prepareOffsetCommitResponse(tp1, error));
-
-                Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
-                offsets.put(tp1,  new OffsetAndMetadata(123L));
-                AlterStreamsGroupOffsetsResult errorResult = env.adminClient()
-                    .alterStreamsGroupOffsets(GROUP_ID, offsets);
-
-                TestUtils.assertFutureThrows(error.exception().getClass(), errorResult.all());
-                TestUtils.assertFutureThrows(error.exception().getClass(), errorResult.partitionResult(tp1));
-            }
-        }
-    }
-
     @Test
     public void testAlterConsumerGroupOffsetsFindCoordinatorRetriableErrors() throws Exception {
         // Retriable FindCoordinatorResponse errors should be retried
@@ -7285,36 +6495,6 @@ public class KafkaAdminClientTest {
         }
     }
 
-    @Test
-    public void testAlterStreamsGroupOffsetsFindCoordinatorRetriableErrors() throws Exception {
-        // Retriable FindCoordinatorResponse errors should be retried
-
-        final TopicPartition tp1 = new TopicPartition("foo", 0);
-
-        try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
-            env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-
-            env.kafkaClient().prepareResponse(
-                prepareFindCoordinatorResponse(Errors.COORDINATOR_NOT_AVAILABLE, Node.noNode()));
-            env.kafkaClient().prepareResponse(
-                prepareFindCoordinatorResponse(Errors.COORDINATOR_LOAD_IN_PROGRESS, Node.noNode()));
-
-            env.kafkaClient().prepareResponse(
-                prepareFindCoordinatorResponse(Errors.NONE, env.cluster().controller()));
-
-            env.kafkaClient().prepareResponse(
-                prepareOffsetCommitResponse(tp1, Errors.NONE));
-
-            Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
-            offsets.put(tp1,  new OffsetAndMetadata(123L));
-            final AlterStreamsGroupOffsetsResult result = env.adminClient()
-                .alterStreamsGroupOffsets(GROUP_ID, offsets);
-
-            assertNull(result.all().get());
-            assertNull(result.partitionResult(tp1).get());
-        }
-    }
-
     @Test
     public void testAlterConsumerGroupOffsetsFindCoordinatorNonRetriableErrors() throws Exception {
         // Non-retriable FindCoordinatorResponse errors throw an exception
@@ -7337,28 +6517,6 @@ public class KafkaAdminClientTest {
         }
     }
 
-    @Test
-    public void testAlterStreamsGroupOffsetsFindCoordinatorNonRetriableErrors() throws Exception {
-        // Non-retriable FindCoordinatorResponse errors throw an exception
-
-        final TopicPartition tp1 = new TopicPartition("foo", 0);
-
-        try (AdminClientUnitTestEnv env = new AdminClientUnitTestEnv(mockCluster(1, 0))) {
-            env.kafkaClient().setNodeApiVersions(NodeApiVersions.create());
-
-            env.kafkaClient().prepareResponse(
-                prepareFindCoordinatorResponse(Errors.GROUP_AUTHORIZATION_FAILED,  Node.noNode()));
-
-            Map<TopicPartition, OffsetAndMetadata> offsets = new HashMap<>();
-            offsets.put(tp1,  new OffsetAndMetadata(123L));
-            final AlterStreamsGroupOffsetsResult errorResult = env.adminClient()
-                .alterStreamsGroupOffsets(GROUP_ID, offsets);
-
-            TestUtils.assertFutureThrows(GroupAuthorizationException.class, errorResult.all());
-            TestUtils.assertFutureThrows(GroupAuthorizationException.class, errorResult.partitionResult(tp1));
-        }
-    }
-
     @Test
     public void testListOffsets() throws Exception {
         // Happy path
diff --git a/clients/src/test/java/org/apache/kafka/clients/admin/MockAdminClient.java b/clients/src/test/java/org/apache/kafka/clients/admin/MockAdminClient.java
index b61915e4a8d..5c56665eb7d 100644
--- a/clients/src/test/java/org/apache/kafka/clients/admin/MockAdminClient.java
+++ b/clients/src/test/java/org/apache/kafka/clients/admin/MockAdminClient.java
@@ -756,36 +756,16 @@ public class MockAdminClient extends AdminClient {
         return new ListConsumerGroupOffsetsResult(Collections.singletonMap(CoordinatorKey.byGroupId(group), future));
     }
 
-    @Override
-    public synchronized ListStreamsGroupOffsetsResult listStreamsGroupOffsets(Map<String, ListStreamsGroupOffsetsSpec> groupSpecs, ListStreamsGroupOffsetsOptions options) {
-        Map<String, ListConsumerGroupOffsetsSpec> consumerGroupSpecs = groupSpecs.entrySet().stream()
-            .collect(Collectors.toMap(
-                Map.Entry::getKey,
-                entry -> new ListConsumerGroupOffsetsSpec().topicPartitions(entry.getValue().topicPartitions())
-            ));
-        return new ListStreamsGroupOffsetsResult(listConsumerGroupOffsets(consumerGroupSpecs, new ListConsumerGroupOffsetsOptions()));
-    }
-
     @Override
     public synchronized DeleteConsumerGroupsResult deleteConsumerGroups(Collection<String> groupIds, DeleteConsumerGroupsOptions options) {
         throw new UnsupportedOperationException("Not implemented yet");
     }
 
-    @Override
-    public synchronized DeleteStreamsGroupsResult deleteStreamsGroups(Collection<String> groupIds, DeleteStreamsGroupsOptions options) {
-        throw new UnsupportedOperationException("Not implemented yet");
-    }
-
     @Override
     public synchronized DeleteConsumerGroupOffsetsResult deleteConsumerGroupOffsets(String groupId, Set<TopicPartition> partitions, DeleteConsumerGroupOffsetsOptions options) {
         throw new UnsupportedOperationException("Not implemented yet");
     }
 
-    @Override
-    public synchronized DeleteStreamsGroupOffsetsResult deleteStreamsGroupOffsets(String groupId, Set<TopicPartition> partitions, DeleteStreamsGroupOffsetsOptions options) {
-        throw new UnsupportedOperationException("Not implemented yet");
-    }
-
     @Override
     public synchronized ElectLeadersResult electLeaders(
             ElectionType electionType,
@@ -1214,11 +1194,6 @@ public class MockAdminClient extends AdminClient {
         throw new UnsupportedOperationException("Not implement yet");
     }
 
-    @Override
-    public synchronized AlterStreamsGroupOffsetsResult alterStreamsGroupOffsets(String groupId, Map<TopicPartition, OffsetAndMetadata> offsets, AlterStreamsGroupOffsetsOptions options) {
-        throw new UnsupportedOperationException("Not implement yet");
-    }
-
     @Override
     public synchronized ListOffsetsResult listOffsets(Map<TopicPartition, OffsetSpec> topicPartitionOffsets, ListOffsetsOptions options) {
         Map<TopicPartition, KafkaFuture<ListOffsetsResult.ListOffsetsResultInfo>> futures = new HashMap<>();
diff --git a/streams/integration-tests/src/test/java/org/apache/kafka/streams/integration/TestingMetricsInterceptingAdminClient.java b/streams/integration-tests/src/test/java/org/apache/kafka/streams/integration/TestingMetricsInterceptingAdminClient.java
index ede78ca71ab..c996e148b2b 100644
--- a/streams/integration-tests/src/test/java/org/apache/kafka/streams/integration/TestingMetricsInterceptingAdminClient.java
+++ b/streams/integration-tests/src/test/java/org/apache/kafka/streams/integration/TestingMetricsInterceptingAdminClient.java
@@ -37,8 +37,6 @@ import org.apache.kafka.clients.admin.AlterReplicaLogDirsOptions;
 import org.apache.kafka.clients.admin.AlterReplicaLogDirsResult;
 import org.apache.kafka.clients.admin.AlterShareGroupOffsetsOptions;
 import org.apache.kafka.clients.admin.AlterShareGroupOffsetsResult;
-import org.apache.kafka.clients.admin.AlterStreamsGroupOffsetsOptions;
-import org.apache.kafka.clients.admin.AlterStreamsGroupOffsetsResult;
 import org.apache.kafka.clients.admin.AlterUserScramCredentialsOptions;
 import org.apache.kafka.clients.admin.AlterUserScramCredentialsResult;
 import org.apache.kafka.clients.admin.CreateAclsOptions;
@@ -59,10 +57,6 @@ import org.apache.kafka.clients.admin.DeleteRecordsOptions;
 import org.apache.kafka.clients.admin.DeleteRecordsResult;
 import org.apache.kafka.clients.admin.DeleteShareGroupsOptions;
 import org.apache.kafka.clients.admin.DeleteShareGroupsResult;
-import org.apache.kafka.clients.admin.DeleteStreamsGroupOffsetsOptions;
-import org.apache.kafka.clients.admin.DeleteStreamsGroupOffsetsResult;
-import org.apache.kafka.clients.admin.DeleteStreamsGroupsOptions;
-import org.apache.kafka.clients.admin.DeleteStreamsGroupsResult;
 import org.apache.kafka.clients.admin.DeleteTopicsOptions;
 import org.apache.kafka.clients.admin.DeleteTopicsResult;
 import org.apache.kafka.clients.admin.DescribeAclsOptions;
@@ -120,9 +114,6 @@ import org.apache.kafka.clients.admin.ListPartitionReassignmentsResult;
 import org.apache.kafka.clients.admin.ListShareGroupOffsetsOptions;
 import org.apache.kafka.clients.admin.ListShareGroupOffsetsResult;
 import org.apache.kafka.clients.admin.ListShareGroupOffsetsSpec;
-import org.apache.kafka.clients.admin.ListStreamsGroupOffsetsOptions;
-import org.apache.kafka.clients.admin.ListStreamsGroupOffsetsResult;
-import org.apache.kafka.clients.admin.ListStreamsGroupOffsetsSpec;
 import org.apache.kafka.clients.admin.ListTopicsOptions;
 import org.apache.kafka.clients.admin.ListTopicsResult;
 import org.apache.kafka.clients.admin.ListTransactionsOptions;
@@ -299,31 +290,16 @@ public class TestingMetricsInterceptingAdminClient extends AdminClient {
         return adminDelegate.listConsumerGroupOffsets(groupSpecs, options);
     }
 
-    @Override
-    public ListStreamsGroupOffsetsResult listStreamsGroupOffsets(final Map<String, ListStreamsGroupOffsetsSpec> groupSpecs, final ListStreamsGroupOffsetsOptions options) {
-        return adminDelegate.listStreamsGroupOffsets(groupSpecs, options);
-    }
-
     @Override
     public DeleteConsumerGroupsResult deleteConsumerGroups(final Collection<String> groupIds, final DeleteConsumerGroupsOptions options) {
         return adminDelegate.deleteConsumerGroups(groupIds, options);
     }
 
-    @Override
-    public DeleteStreamsGroupsResult deleteStreamsGroups(final Collection<String> groupIds, final DeleteStreamsGroupsOptions options) {
-        return adminDelegate.deleteStreamsGroups(groupIds, options);
-    }
-
     @Override
     public DeleteConsumerGroupOffsetsResult deleteConsumerGroupOffsets(final String groupId, final Set<TopicPartition> partitions, final DeleteConsumerGroupOffsetsOptions options) {
         return adminDelegate.deleteConsumerGroupOffsets(groupId, partitions, options);
     }
 
-    @Override
-    public DeleteStreamsGroupOffsetsResult deleteStreamsGroupOffsets(final String groupId, final Set<TopicPartition> partitions, final DeleteStreamsGroupOffsetsOptions options) {
-        return adminDelegate.deleteStreamsGroupOffsets(groupId, partitions, options);
-    }
-
     @Override
     public ElectLeadersResult electLeaders(final ElectionType electionType, final Set<TopicPartition> partitions, final ElectLeadersOptions options) {
         return adminDelegate.electLeaders(electionType, partitions, options);
@@ -349,11 +325,6 @@ public class TestingMetricsInterceptingAdminClient extends AdminClient {
         return adminDelegate.alterConsumerGroupOffsets(groupId, offsets, options);
     }
 
-    @Override
-    public AlterStreamsGroupOffsetsResult alterStreamsGroupOffsets(final String groupId, final Map<TopicPartition, OffsetAndMetadata> offsets, final AlterStreamsGroupOffsetsOptions options) {
-        return adminDelegate.alterStreamsGroupOffsets(groupId, offsets, options);
-    }
-
     @Override
     public ListOffsetsResult listOffsets(final Map<TopicPartition, OffsetSpec> topicPartitionOffsets, final ListOffsetsOptions options) {
         return adminDelegate.listOffsets(topicPartitionOffsets, options);