mockssarama.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/IBM/sarama (interfaces: Client,ClusterAdmin)
//
// Generated by this command:
//
//	mockgen -self_package github.com/lovoo/goka -package goka -destination mockssarama.go github.com/IBM/sarama Client,ClusterAdmin
//

// Package goka is a generated GoMock package.
package goka

import (
	reflect "reflect"

	sarama "github.com/IBM/sarama"
	gomock "go.uber.org/mock/gomock"
)

// MockClient is a mock of Client interface.
type MockClient struct {
	ctrl     *gomock.Controller
	recorder *MockClientMockRecorder
	isgomock struct{}
}

// MockClientMockRecorder is the mock recorder for MockClient.
type MockClientMockRecorder struct {
	mock *MockClient
}

// NewMockClient creates a new mock instance.
func NewMockClient(ctrl *gomock.Controller) *MockClient {
	mock := &MockClient{ctrl: ctrl}
	mock.recorder = &MockClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockClient) EXPECT() *MockClientMockRecorder {
	return m.recorder
}

// Broker mocks base method.
func (m *MockClient) Broker(brokerID int32) (*sarama.Broker, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Broker", brokerID)
	ret0, _ := ret[0].(*sarama.Broker)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Broker indicates an expected call of Broker.
func (mr *MockClientMockRecorder) Broker(brokerID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Broker", reflect.TypeOf((*MockClient)(nil).Broker), brokerID)
}

// Brokers mocks base method.
func (m *MockClient) Brokers() []*sarama.Broker {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Brokers")
	ret0, _ := ret[0].([]*sarama.Broker)
	return ret0
}

// Brokers indicates an expected call of Brokers.
func (mr *MockClientMockRecorder) Brokers() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Brokers", reflect.TypeOf((*MockClient)(nil).Brokers))
}

// Close mocks base method.
func (m *MockClient) Close() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close.
func (mr *MockClientMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockClient)(nil).Close))
}

// Closed mocks base method.
func (m *MockClient) Closed() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Closed")
	ret0, _ := ret[0].(bool)
	return ret0
}

// Closed indicates an expected call of Closed.
func (mr *MockClientMockRecorder) Closed() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Closed", reflect.TypeOf((*MockClient)(nil).Closed))
}

// Config mocks base method.
func (m *MockClient) Config() *sarama.Config {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Config")
	ret0, _ := ret[0].(*sarama.Config)
	return ret0
}

// Config indicates an expected call of Config.
func (mr *MockClientMockRecorder) Config() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Config", reflect.TypeOf((*MockClient)(nil).Config))
}

// Controller mocks base method.
func (m *MockClient) Controller() (*sarama.Broker, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Controller")
	ret0, _ := ret[0].(*sarama.Broker)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Controller indicates an expected call of Controller.
func (mr *MockClientMockRecorder) Controller() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Controller", reflect.TypeOf((*MockClient)(nil).Controller))
}

// Coordinator mocks base method.
func (m *MockClient) Coordinator(consumerGroup string) (*sarama.Broker, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Coordinator", consumerGroup)
	ret0, _ := ret[0].(*sarama.Broker)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Coordinator indicates an expected call of Coordinator.
func (mr *MockClientMockRecorder) Coordinator(consumerGroup any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Coordinator", reflect.TypeOf((*MockClient)(nil).Coordinator), consumerGroup)
}

// GetOffset mocks base method.
func (m *MockClient) GetOffset(topic string, partitionID int32, time int64) (int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOffset", topic, partitionID, time)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOffset indicates an expected call of GetOffset.
func (mr *MockClientMockRecorder) GetOffset(topic, partitionID, time any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOffset", reflect.TypeOf((*MockClient)(nil).GetOffset), topic, partitionID, time)
}

// InSyncReplicas mocks base method.
func (m *MockClient) InSyncReplicas(topic string, partitionID int32) ([]int32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InSyncReplicas", topic, partitionID)
	ret0, _ := ret[0].([]int32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InSyncReplicas indicates an expected call of InSyncReplicas.
func (mr *MockClientMockRecorder) InSyncReplicas(topic, partitionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InSyncReplicas", reflect.TypeOf((*MockClient)(nil).InSyncReplicas), topic, partitionID)
}

// InitProducerID mocks base method.
func (m *MockClient) InitProducerID() (*sarama.InitProducerIDResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InitProducerID")
	ret0, _ := ret[0].(*sarama.InitProducerIDResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InitProducerID indicates an expected call of InitProducerID.
func (mr *MockClientMockRecorder) InitProducerID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitProducerID", reflect.TypeOf((*MockClient)(nil).InitProducerID))
}

// Leader mocks base method.
func (m *MockClient) Leader(topic string, partitionID int32) (*sarama.Broker, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Leader", topic, partitionID)
	ret0, _ := ret[0].(*sarama.Broker)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Leader indicates an expected call of Leader.
func (mr *MockClientMockRecorder) Leader(topic, partitionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Leader", reflect.TypeOf((*MockClient)(nil).Leader), topic, partitionID)
}

// LeaderAndEpoch mocks base method.
func (m *MockClient) LeaderAndEpoch(topic string, partitionID int32) (*sarama.Broker, int32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LeaderAndEpoch", topic, partitionID)
	ret0, _ := ret[0].(*sarama.Broker)
	ret1, _ := ret[1].(int32)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// LeaderAndEpoch indicates an expected call of LeaderAndEpoch.
func (mr *MockClientMockRecorder) LeaderAndEpoch(topic, partitionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LeaderAndEpoch", reflect.TypeOf((*MockClient)(nil).LeaderAndEpoch), topic, partitionID)
}

// LeastLoadedBroker mocks base method.
func (m *MockClient) LeastLoadedBroker() *sarama.Broker {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LeastLoadedBroker")
	ret0, _ := ret[0].(*sarama.Broker)
	return ret0
}

// LeastLoadedBroker indicates an expected call of LeastLoadedBroker.
func (mr *MockClientMockRecorder) LeastLoadedBroker() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LeastLoadedBroker", reflect.TypeOf((*MockClient)(nil).LeastLoadedBroker))
}

// OfflineReplicas mocks base method.
func (m *MockClient) OfflineReplicas(topic string, partitionID int32) ([]int32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OfflineReplicas", topic, partitionID)
	ret0, _ := ret[0].([]int32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OfflineReplicas indicates an expected call of OfflineReplicas.
func (mr *MockClientMockRecorder) OfflineReplicas(topic, partitionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OfflineReplicas", reflect.TypeOf((*MockClient)(nil).OfflineReplicas), topic, partitionID)
}

// PartitionNotReadable mocks base method.
func (m *MockClient) PartitionNotReadable(topic string, partition int32) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PartitionNotReadable", topic, partition)
	ret0, _ := ret[0].(bool)
	return ret0
}

// PartitionNotReadable indicates an expected call of PartitionNotReadable.
func (mr *MockClientMockRecorder) PartitionNotReadable(topic, partition any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PartitionNotReadable", reflect.TypeOf((*MockClient)(nil).PartitionNotReadable), topic, partition)
}

// Partitions mocks base method.
func (m *MockClient) Partitions(topic string) ([]int32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Partitions", topic)
	ret0, _ := ret[0].([]int32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Partitions indicates an expected call of Partitions.
func (mr *MockClientMockRecorder) Partitions(topic any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Partitions", reflect.TypeOf((*MockClient)(nil).Partitions), topic)
}

// RefreshBrokers mocks base method.
func (m *MockClient) RefreshBrokers(addrs []string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RefreshBrokers", addrs)
	ret0, _ := ret[0].(error)
	return ret0
}

// RefreshBrokers indicates an expected call of RefreshBrokers.
func (mr *MockClientMockRecorder) RefreshBrokers(addrs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RefreshBrokers", reflect.TypeOf((*MockClient)(nil).RefreshBrokers), addrs)
}

// RefreshController mocks base method.
func (m *MockClient) RefreshController() (*sarama.Broker, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RefreshController")
	ret0, _ := ret[0].(*sarama.Broker)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RefreshController indicates an expected call of RefreshController.
func (mr *MockClientMockRecorder) RefreshController() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RefreshController", reflect.TypeOf((*MockClient)(nil).RefreshController))
}

// RefreshCoordinator mocks base method.
func (m *MockClient) RefreshCoordinator(consumerGroup string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RefreshCoordinator", consumerGroup)
	ret0, _ := ret[0].(error)
	return ret0
}

// RefreshCoordinator indicates an expected call of RefreshCoordinator.
func (mr *MockClientMockRecorder) RefreshCoordinator(consumerGroup any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RefreshCoordinator", reflect.TypeOf((*MockClient)(nil).RefreshCoordinator), consumerGroup)
}

// RefreshMetadata mocks base method.
func (m *MockClient) RefreshMetadata(topics ...string) error {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range topics {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RefreshMetadata", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// RefreshMetadata indicates an expected call of RefreshMetadata.
func (mr *MockClientMockRecorder) RefreshMetadata(topics ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RefreshMetadata", reflect.TypeOf((*MockClient)(nil).RefreshMetadata), topics...)
}

// RefreshTransactionCoordinator mocks base method.
func (m *MockClient) RefreshTransactionCoordinator(transactionID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RefreshTransactionCoordinator", transactionID)
	ret0, _ := ret[0].(error)
	return ret0
}

// RefreshTransactionCoordinator indicates an expected call of RefreshTransactionCoordinator.
func (mr *MockClientMockRecorder) RefreshTransactionCoordinator(transactionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RefreshTransactionCoordinator", reflect.TypeOf((*MockClient)(nil).RefreshTransactionCoordinator), transactionID)
}

// Replicas mocks base method.
func (m *MockClient) Replicas(topic string, partitionID int32) ([]int32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Replicas", topic, partitionID)
	ret0, _ := ret[0].([]int32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Replicas indicates an expected call of Replicas.
func (mr *MockClientMockRecorder) Replicas(topic, partitionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Replicas", reflect.TypeOf((*MockClient)(nil).Replicas), topic, partitionID)
}

// Topics mocks base method.
func (m *MockClient) Topics() ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Topics")
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Topics indicates an expected call of Topics.
func (mr *MockClientMockRecorder) Topics() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Topics", reflect.TypeOf((*MockClient)(nil).Topics))
}

// TransactionCoordinator mocks base method.
func (m *MockClient) TransactionCoordinator(transactionID string) (*sarama.Broker, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TransactionCoordinator", transactionID)
	ret0, _ := ret[0].(*sarama.Broker)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TransactionCoordinator indicates an expected call of TransactionCoordinator.
func (mr *MockClientMockRecorder) TransactionCoordinator(transactionID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TransactionCoordinator", reflect.TypeOf((*MockClient)(nil).TransactionCoordinator), transactionID)
}

// WritablePartitions mocks base method.
func (m *MockClient) WritablePartitions(topic string) ([]int32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WritablePartitions", topic)
	ret0, _ := ret[0].([]int32)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WritablePartitions indicates an expected call of WritablePartitions.
func (mr *MockClientMockRecorder) WritablePartitions(topic any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WritablePartitions", reflect.TypeOf((*MockClient)(nil).WritablePartitions), topic)
}

// MockClusterAdmin is a mock of ClusterAdmin interface.
type MockClusterAdmin struct {
	ctrl     *gomock.Controller
	recorder *MockClusterAdminMockRecorder
	isgomock struct{}
}

// MockClusterAdminMockRecorder is the mock recorder for MockClusterAdmin.
type MockClusterAdminMockRecorder struct {
	mock *MockClusterAdmin
}

// NewMockClusterAdmin creates a new mock instance.
func NewMockClusterAdmin(ctrl *gomock.Controller) *MockClusterAdmin {
	mock := &MockClusterAdmin{ctrl: ctrl}
	mock.recorder = &MockClusterAdminMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockClusterAdmin) EXPECT() *MockClusterAdminMockRecorder {
	return m.recorder
}

// AlterClientQuotas mocks base method.
func (m *MockClusterAdmin) AlterClientQuotas(entity []sarama.QuotaEntityComponent, op sarama.ClientQuotasOp, validateOnly bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AlterClientQuotas", entity, op, validateOnly)
	ret0, _ := ret[0].(error)
	return ret0
}

// AlterClientQuotas indicates an expected call of AlterClientQuotas.
func (mr *MockClusterAdminMockRecorder) AlterClientQuotas(entity, op, validateOnly any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AlterClientQuotas", reflect.TypeOf((*MockClusterAdmin)(nil).AlterClientQuotas), entity, op, validateOnly)
}

// AlterConfig mocks base method.
func (m *MockClusterAdmin) AlterConfig(resourceType sarama.ConfigResourceType, name string, entries map[string]*string, validateOnly bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AlterConfig", resourceType, name, entries, validateOnly)
	ret0, _ := ret[0].(error)
	return ret0
}

// AlterConfig indicates an expected call of AlterConfig.
func (mr *MockClusterAdminMockRecorder) AlterConfig(resourceType, name, entries, validateOnly any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AlterConfig", reflect.TypeOf((*MockClusterAdmin)(nil).AlterConfig), resourceType, name, entries, validateOnly)
}

// AlterPartitionReassignments mocks base method.
func (m *MockClusterAdmin) AlterPartitionReassignments(topic string, assignment [][]int32) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AlterPartitionReassignments", topic, assignment)
	ret0, _ := ret[0].(error)
	return ret0
}

// AlterPartitionReassignments indicates an expected call of AlterPartitionReassignments.
func (mr *MockClusterAdminMockRecorder) AlterPartitionReassignments(topic, assignment any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AlterPartitionReassignments", reflect.TypeOf((*MockClusterAdmin)(nil).AlterPartitionReassignments), topic, assignment)
}

// Close mocks base method.
func (m *MockClusterAdmin) Close() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close.
func (mr *MockClusterAdminMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockClusterAdmin)(nil).Close))
}

// Controller mocks base method.
func (m *MockClusterAdmin) Controller() (*sarama.Broker, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Controller")
	ret0, _ := ret[0].(*sarama.Broker)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Controller indicates an expected call of Controller.
func (mr *MockClusterAdminMockRecorder) Controller() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Controller", reflect.TypeOf((*MockClusterAdmin)(nil).Controller))
}

// Coordinator mocks base method.
func (m *MockClusterAdmin) Coordinator(group string) (*sarama.Broker, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Coordinator", group)
	ret0, _ := ret[0].(*sarama.Broker)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Coordinator indicates an expected call of Coordinator.
func (mr *MockClusterAdminMockRecorder) Coordinator(group any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Coordinator", reflect.TypeOf((*MockClusterAdmin)(nil).Coordinator), group)
}

// CreateACL mocks base method.
func (m *MockClusterAdmin) CreateACL(resource sarama.Resource, acl sarama.Acl) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateACL", resource, acl)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateACL indicates an expected call of CreateACL.
func (mr *MockClusterAdminMockRecorder) CreateACL(resource, acl any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateACL", reflect.TypeOf((*MockClusterAdmin)(nil).CreateACL), resource, acl)
}

// CreateACLs mocks base method.
func (m *MockClusterAdmin) CreateACLs(arg0 []*sarama.ResourceAcls) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateACLs", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateACLs indicates an expected call of CreateACLs.
func (mr *MockClusterAdminMockRecorder) CreateACLs(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateACLs", reflect.TypeOf((*MockClusterAdmin)(nil).CreateACLs), arg0)
}

// CreatePartitions mocks base method.
func (m *MockClusterAdmin) CreatePartitions(topic string, count int32, assignment [][]int32, validateOnly bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePartitions", topic, count, assignment, validateOnly)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreatePartitions indicates an expected call of CreatePartitions.
func (mr *MockClusterAdminMockRecorder) CreatePartitions(topic, count, assignment, validateOnly any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePartitions", reflect.TypeOf((*MockClusterAdmin)(nil).CreatePartitions), topic, count, assignment, validateOnly)
}

// CreateTopic mocks base method.
func (m *MockClusterAdmin) CreateTopic(topic string, detail *sarama.TopicDetail, validateOnly bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTopic", topic, detail, validateOnly)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateTopic indicates an expected call of CreateTopic.
func (mr *MockClusterAdminMockRecorder) CreateTopic(topic, detail, validateOnly any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTopic", reflect.TypeOf((*MockClusterAdmin)(nil).CreateTopic), topic, detail, validateOnly)
}

// DeleteACL mocks base method.
func (m *MockClusterAdmin) DeleteACL(filter sarama.AclFilter, validateOnly bool) ([]sarama.MatchingAcl, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteACL", filter, validateOnly)
	ret0, _ := ret[0].([]sarama.MatchingAcl)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteACL indicates an expected call of DeleteACL.
func (mr *MockClusterAdminMockRecorder) DeleteACL(filter, validateOnly any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteACL", reflect.TypeOf((*MockClusterAdmin)(nil).DeleteACL), filter, validateOnly)
}

// DeleteConsumerGroup mocks base method.
func (m *MockClusterAdmin) DeleteConsumerGroup(group string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteConsumerGroup", group)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteConsumerGroup indicates an expected call of DeleteConsumerGroup.
func (mr *MockClusterAdminMockRecorder) DeleteConsumerGroup(group any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConsumerGroup", reflect.TypeOf((*MockClusterAdmin)(nil).DeleteConsumerGroup), group)
}

// DeleteConsumerGroupOffset mocks base method.
func (m *MockClusterAdmin) DeleteConsumerGroupOffset(group, topic string, partition int32) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteConsumerGroupOffset", group, topic, partition)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteConsumerGroupOffset indicates an expected call of DeleteConsumerGroupOffset.
func (mr *MockClusterAdminMockRecorder) DeleteConsumerGroupOffset(group, topic, partition any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteConsumerGroupOffset", reflect.TypeOf((*MockClusterAdmin)(nil).DeleteConsumerGroupOffset), group, topic, partition)
}

// DeleteRecords mocks base method.
func (m *MockClusterAdmin) DeleteRecords(topic string, partitionOffsets map[int32]int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteRecords", topic, partitionOffsets)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteRecords indicates an expected call of DeleteRecords.
func (mr *MockClusterAdminMockRecorder) DeleteRecords(topic, partitionOffsets any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRecords", reflect.TypeOf((*MockClusterAdmin)(nil).DeleteRecords), topic, partitionOffsets)
}

// DeleteTopic mocks base method.
func (m *MockClusterAdmin) DeleteTopic(topic string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteTopic", topic)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteTopic indicates an expected call of DeleteTopic.
func (mr *MockClusterAdminMockRecorder) DeleteTopic(topic any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTopic", reflect.TypeOf((*MockClusterAdmin)(nil).DeleteTopic), topic)
}

// DeleteUserScramCredentials mocks base method.
func (m *MockClusterAdmin) DeleteUserScramCredentials(delete []sarama.AlterUserScramCredentialsDelete) ([]*sarama.AlterUserScramCredentialsResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteUserScramCredentials", delete)
	ret0, _ := ret[0].([]*sarama.AlterUserScramCredentialsResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteUserScramCredentials indicates an expected call of DeleteUserScramCredentials.
func (mr *MockClusterAdminMockRecorder) DeleteUserScramCredentials(delete any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserScramCredentials", reflect.TypeOf((*MockClusterAdmin)(nil).DeleteUserScramCredentials), delete)
}

// DescribeClientQuotas mocks base method.
func (m *MockClusterAdmin) DescribeClientQuotas(components []sarama.QuotaFilterComponent, strict bool) ([]sarama.DescribeClientQuotasEntry, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeClientQuotas", components, strict)
	ret0, _ := ret[0].([]sarama.DescribeClientQuotasEntry)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeClientQuotas indicates an expected call of DescribeClientQuotas.
func (mr *MockClusterAdminMockRecorder) DescribeClientQuotas(components, strict any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientQuotas", reflect.TypeOf((*MockClusterAdmin)(nil).DescribeClientQuotas), components, strict)
}

// DescribeCluster mocks base method.
func (m *MockClusterAdmin) DescribeCluster() ([]*sarama.Broker, int32, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCluster")
	ret0, _ := ret[0].([]*sarama.Broker)
	ret1, _ := ret[1].(int32)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// DescribeCluster indicates an expected call of DescribeCluster.
func (mr *MockClusterAdminMockRecorder) DescribeCluster() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCluster", reflect.TypeOf((*MockClusterAdmin)(nil).DescribeCluster))
}

// DescribeConfig mocks base method.
func (m *MockClusterAdmin) DescribeConfig(resource sarama.ConfigResource) ([]sarama.ConfigEntry, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeConfig", resource)
	ret0, _ := ret[0].([]sarama.ConfigEntry)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeConfig indicates an expected call of DescribeConfig.
func (mr *MockClusterAdminMockRecorder) DescribeConfig(resource any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConfig", reflect.TypeOf((*MockClusterAdmin)(nil).DescribeConfig), resource)
}

// DescribeConsumerGroups mocks base method.
func (m *MockClusterAdmin) DescribeConsumerGroups(groups []string) ([]*sarama.GroupDescription, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeConsumerGroups", groups)
	ret0, _ := ret[0].([]*sarama.GroupDescription)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeConsumerGroups indicates an expected call of DescribeConsumerGroups.
func (mr *MockClusterAdminMockRecorder) DescribeConsumerGroups(groups any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConsumerGroups", reflect.TypeOf((*MockClusterAdmin)(nil).DescribeConsumerGroups), groups)
}

// DescribeLogDirs mocks base method.
func (m *MockClusterAdmin) DescribeLogDirs(brokers []int32) (map[int32][]sarama.DescribeLogDirsResponseDirMetadata, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeLogDirs", brokers)
	ret0, _ := ret[0].(map[int32][]sarama.DescribeLogDirsResponseDirMetadata)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeLogDirs indicates an expected call of DescribeLogDirs.
func (mr *MockClusterAdminMockRecorder) DescribeLogDirs(brokers any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLogDirs", reflect.TypeOf((*MockClusterAdmin)(nil).DescribeLogDirs), brokers)
}

// DescribeTopics mocks base method.
func (m *MockClusterAdmin) DescribeTopics(topics []string) ([]*sarama.TopicMetadata, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTopics", topics)
	ret0, _ := ret[0].([]*sarama.TopicMetadata)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTopics indicates an expected call of DescribeTopics.
func (mr *MockClusterAdminMockRecorder) DescribeTopics(topics any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTopics", reflect.TypeOf((*MockClusterAdmin)(nil).DescribeTopics), topics)
}

// DescribeUserScramCredentials mocks base method.
func (m *MockClusterAdmin) DescribeUserScramCredentials(users []string) ([]*sarama.DescribeUserScramCredentialsResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeUserScramCredentials", users)
	ret0, _ := ret[0].([]*sarama.DescribeUserScramCredentialsResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeUserScramCredentials indicates an expected call of DescribeUserScramCredentials.
func (mr *MockClusterAdminMockRecorder) DescribeUserScramCredentials(users any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeUserScramCredentials", reflect.TypeOf((*MockClusterAdmin)(nil).DescribeUserScramCredentials), users)
}

// ElectLeaders mocks base method.
func (m *MockClusterAdmin) ElectLeaders(arg0 sarama.ElectionType, arg1 map[string][]int32) (map[string]map[int32]*sarama.PartitionResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ElectLeaders", arg0, arg1)
	ret0, _ := ret[0].(map[string]map[int32]*sarama.PartitionResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ElectLeaders indicates an expected call of ElectLeaders.
func (mr *MockClusterAdminMockRecorder) ElectLeaders(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ElectLeaders", reflect.TypeOf((*MockClusterAdmin)(nil).ElectLeaders), arg0, arg1)
}

// IncrementalAlterConfig mocks base method.
func (m *MockClusterAdmin) IncrementalAlterConfig(resourceType sarama.ConfigResourceType, name string, entries map[string]sarama.IncrementalAlterConfigsEntry, validateOnly bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IncrementalAlterConfig", resourceType, name, entries, validateOnly)
	ret0, _ := ret[0].(error)
	return ret0
}

// IncrementalAlterConfig indicates an expected call of IncrementalAlterConfig.
func (mr *MockClusterAdminMockRecorder) IncrementalAlterConfig(resourceType, name, entries, validateOnly any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrementalAlterConfig", reflect.TypeOf((*MockClusterAdmin)(nil).IncrementalAlterConfig), resourceType, name, entries, validateOnly)
}

// ListAcls mocks base method.
func (m *MockClusterAdmin) ListAcls(filter sarama.AclFilter) ([]sarama.ResourceAcls, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAcls", filter)
	ret0, _ := ret[0].([]sarama.ResourceAcls)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAcls indicates an expected call of ListAcls.
func (mr *MockClusterAdminMockRecorder) ListAcls(filter any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAcls", reflect.TypeOf((*MockClusterAdmin)(nil).ListAcls), filter)
}

// ListConsumerGroupOffsets mocks base method.
func (m *MockClusterAdmin) ListConsumerGroupOffsets(group string, topicPartitions map[string][]int32) (*sarama.OffsetFetchResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListConsumerGroupOffsets", group, topicPartitions)
	ret0, _ := ret[0].(*sarama.OffsetFetchResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListConsumerGroupOffsets indicates an expected call of ListConsumerGroupOffsets.
func (mr *MockClusterAdminMockRecorder) ListConsumerGroupOffsets(group, topicPartitions any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListConsumerGroupOffsets", reflect.TypeOf((*MockClusterAdmin)(nil).ListConsumerGroupOffsets), group, topicPartitions)
}

// ListConsumerGroups mocks base method.
func (m *MockClusterAdmin) ListConsumerGroups() (map[string]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListConsumerGroups")
	ret0, _ := ret[0].(map[string]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListConsumerGroups indicates an expected call of ListConsumerGroups.
func (mr *MockClusterAdminMockRecorder) ListConsumerGroups() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListConsumerGroups", reflect.TypeOf((*MockClusterAdmin)(nil).ListConsumerGroups))
}

// ListPartitionReassignments mocks base method.
func (m *MockClusterAdmin) ListPartitionReassignments(topics string, partitions []int32) (map[string]map[int32]*sarama.PartitionReplicaReassignmentsStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPartitionReassignments", topics, partitions)
	ret0, _ := ret[0].(map[string]map[int32]*sarama.PartitionReplicaReassignmentsStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPartitionReassignments indicates an expected call of ListPartitionReassignments.
func (mr *MockClusterAdminMockRecorder) ListPartitionReassignments(topics, partitions any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPartitionReassignments", reflect.TypeOf((*MockClusterAdmin)(nil).ListPartitionReassignments), topics, partitions)
}

// ListTopics mocks base method.
func (m *MockClusterAdmin) ListTopics() (map[string]sarama.TopicDetail, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTopics")
	ret0, _ := ret[0].(map[string]sarama.TopicDetail)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTopics indicates an expected call of ListTopics.
func (mr *MockClusterAdminMockRecorder) ListTopics() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTopics", reflect.TypeOf((*MockClusterAdmin)(nil).ListTopics))
}

// RemoveMemberFromConsumerGroup mocks base method.
func (m *MockClusterAdmin) RemoveMemberFromConsumerGroup(groupId string, groupInstanceIds []string) (*sarama.LeaveGroupResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveMemberFromConsumerGroup", groupId, groupInstanceIds)
	ret0, _ := ret[0].(*sarama.LeaveGroupResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveMemberFromConsumerGroup indicates an expected call of RemoveMemberFromConsumerGroup.
func (mr *MockClusterAdminMockRecorder) RemoveMemberFromConsumerGroup(groupId, groupInstanceIds any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveMemberFromConsumerGroup", reflect.TypeOf((*MockClusterAdmin)(nil).RemoveMemberFromConsumerGroup), groupId, groupInstanceIds)
}

// UpsertUserScramCredentials mocks base method.
func (m *MockClusterAdmin) UpsertUserScramCredentials(upsert []sarama.AlterUserScramCredentialsUpsert) ([]*sarama.AlterUserScramCredentialsResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpsertUserScramCredentials", upsert)
	ret0, _ := ret[0].([]*sarama.AlterUserScramCredentialsResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpsertUserScramCredentials indicates an expected call of UpsertUserScramCredentials.
func (mr *MockClusterAdminMockRecorder) UpsertUserScramCredentials(upsert any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertUserScramCredentials", reflect.TypeOf((*MockClusterAdmin)(nil).UpsertUserScramCredentials), upsert)
}