public abstract class AdminClient implements AutoCloseable {
 	
	public abstract DescribeGroupsResultDescribeConsumerGroupsResult describeGroupsdescribeConsumerGroups(Collection<String> groupIds, DescribeGroupsOptions DescribeConsumerGroupsOptions options);
 
	public DescribeGroupsResultDescribeConsumerGroupsResult describeGroupsdescribeConsumerGroups(Collection<String> groupIds) {
    	return describeGroupsdescribeConsumerGroups(groupIds, new DescribeGroupsOptionsDescribeConsumerGroupsOptions());
	}
 
    public abstract ListGroupsResultListConsumerGroupsResult listGroupslistConsumerGroups(ListGroupsOptionsListConsumerGroupsOptions options);

    public ListGroupsResultListConsumerGroupsResult listGroupslistConsumerGroups() {
        return listGroupslistConsumerGroups(new ListGroupsOptionsListConsumerGroupsOptions());
    }

    public abstract ListGroupsResultListConsumerGroupOffsetsResult listGroups(ListGroupsOptionslistConsumerGroupOffsets(String groupId, ListConsumerGroupsOptions options) {
        //filtering groups by ConsumerProtocol.PROTOCOL_TYPE
    }

   ;
 
    public ListGroupsResultListConsumerGroupOffsetsResult listGroupslistConsumerGroupOffsets(String groupId) {
        return listGroupslistConsumerGroupOffsets(new ListGroupsOptionsListConsumerGroupOffsetsOptions());
    }
 
    
public abstract DeleteConsumerGroupsResult deleteConsumerGroups(Collection<String> public ListGroupOffsetsResult listGroupOffsets(ListGroupsOptionsgroupIds, DeleteConsumerGroupsOptions options);
 
    public ListGroupOffsetsResultDeleteConsumerGroupsResult listGroupOffsetsdeleteConsumerGroups(Collection<String> groupIds) {
        return listGroupOffsetsdeleteConsumerGroups(groupIds, new ListGroupOffsetsOptionsDeleteConsumerGroupsOptions());
    }
}
 
public class DescribeGroupOptionsDescribeConsumerGroupOptions extends AbstractOptions<DescribeGroupOptions>AbstractOptions<DescribeConsumerGroupOptions> {
}
 
public class DescribeGroupResultDescribeConsumerGroupResult {
    private final Map<StringMap<TopicPartition, KafkaFuture<GroupDescription>>KafkaFuture<ConsumerGroupDescription>> futures;
    public DescribeGroupsResult(Map<String, KafkaFuture<GroupDescription>> futures) {
all();
}
 
public class ConsumerGroupDescription {
    /**
     * The id of this.futuresthe =consumer futures;group.
     }
*/
    public Map<String, KafkaFuture<GroupDescription>> valuesString groupId() {
        return futures;;

    }
/**
    public KafkaFuture<Map<String,* GroupDescription>>If all() {
        return KafkaFuture.allOf(futures.values().toArray(new KafkaFuture[0]))consumer group is simple or not.
     */
    public boolean  thenApply(new KafkaFuture.Function<Void, Map<String, GroupDescription>>() {isSimpleConsumerGroup();

    /**
     * A list of the members of the consumer   @Overridegroup.
            */
    public Map<String, GroupDescription> apply(Void v) {Collection<MemberDescription> members();

    /**
     * The consumer group partition assignor.
     */
 Map<String, GroupDescription> descriptions =public new HashMap<>(futures.size()String partitionAssignor();

    /**
     * The consumer group state, or UNKNOWN if the state is for (Map.Entry<String, KafkaFuture<GroupDescription>> entry : futures.entrySet()) {too new for us to parse.
     */
    public ConsumerGroupState state();

             try {/**
     * The consumer group coordinator, or null if the coordinator is not known.
     */
    public  descriptions.put(entry.getKey(), entry.getValue().get());
   Node coordinator();

}


public enum ConsumerGroupState {
    UNKNOWN,
    PREPARING_REBALANCE,
    COMPLETING_REBALANCE,
    STABLE,
    DEAD,
 } catch (InterruptedException | ExecutionException e) { EMPTY;
}
 
public class MemberDescription {

    /**
     * The consumer id of the group member.
            // This should be unreachable, because allOf ensured that all the futures*/
    public String consumerId();

    /**
     * The client id of the group member.
     */
    public   String clientId();

    // completed successfully.**
     * The host where the group member is running.
     */
    public      throw new RuntimeException(eString host();

    /**
     * The assignment of the group member.
         }*/
    public                }
   MemberAssignment assignment();
}
 
public class MemberAssignment {
    private final            return descriptions;
                }
            });
    }
}
 List<TopicPartition> topicPartitions;
}

public class ListConsumerGroupsOptions extends AbstractOptions<ListConsumerGroupsOptions> {
}

public class GroupDescriptionListConsumerGroupsResult {
    privatepublic final String groupIdKafkaFuture<Collection<ConsumerGroupListing>> all();
    privatepublic final String protocolTypeKafkaFuture<Collection<ConsumerGroupListing>> valid();
	public    private final List<ConsumerDescription> consumersKafkaFuture<Collection<Throwable>> errors();
} 
 
public class MemberDescriptionConsumerGroupListing {
    private final String consumerIdgroupId;
    private final Stringboolean clientIdisSimpleConsumerGroup;
    private final String host;
    private final List<TopicPartition> assignment;
}
 
public class ListGroupsOptionsListConsumerGroupOffsetsOptions extends AbstractOptions<ListGroupsOptions>AbstractOptions<ListConsumerGroupsOptions> {
}
 
public class ListGroupsResultListConsumerGroupOffsetsResult {
    final KafkaFuture<Map<StringKafkaFuture<Map<TopicPartition, GroupListing>>OffsetAndMetadata>> future;

    //...all();
}
 
public class GroupListing {
    private final String name;
    private final String protocolType;
}
 
public class ListGroupOffsetsOptionsDeleteConsumerGroupOptions extends AbstractOptions<ListGroupsOptions>AbstractOptions<DeleteConsumerGroupOptions> {
}
 
public class ListGroupOffsetsResultDeleteConsumerGroupsResult {
    final KafkaFuture<Map<TopicPartitionMap<TopicPartition, Long>>KafkaFuture<Void>> future;
 
    //...all();
}