// Code generated by MockGen. DO NOT EDIT.
// Source: admin/integrations.go

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

import (
	context "context"
	reflect "reflect"

	kafka "github.com/aws/aws-sdk-go-v2/service/kafka"
	kms "github.com/aws/aws-sdk-go-v2/service/kms"
	secretsmanager "github.com/aws/aws-sdk-go-v2/service/secretsmanager"
	gomock "github.com/golang/mock/gomock"
	kadm "github.com/twmb/franz-go/pkg/kadm"
)

// MockKafkaClient is a mock of KafkaClient interface.
type MockKafkaClient struct {
	ctrl     *gomock.Controller
	recorder *MockKafkaClientMockRecorder
}

// MockKafkaClientMockRecorder is the mock recorder for MockKafkaClient.
type MockKafkaClientMockRecorder struct {
	mock *MockKafkaClient
}

// NewMockKafkaClient creates a new mock instance.
func NewMockKafkaClient(ctrl *gomock.Controller) *MockKafkaClient {
	mock := &MockKafkaClient{ctrl: ctrl}
	mock.recorder = &MockKafkaClientMockRecorder{mock}
	return mock
}

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

// AlterTopicConfigs mocks base method.
func (m *MockKafkaClient) AlterTopicConfigs(ctx context.Context, configs []kadm.AlterConfig, topics ...string) (kadm.AlterConfigsResponses, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, configs}
	for _, a := range topics {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AlterTopicConfigs", varargs...)
	ret0, _ := ret[0].(kadm.AlterConfigsResponses)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AlterTopicConfigs indicates an expected call of AlterTopicConfigs.
func (mr *MockKafkaClientMockRecorder) AlterTopicConfigs(ctx, configs interface{}, topics ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, configs}, topics...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AlterTopicConfigs", reflect.TypeOf((*MockKafkaClient)(nil).AlterTopicConfigs), varargs...)
}

// CreateACLs mocks base method.
func (m *MockKafkaClient) CreateACLs(ctx context.Context, b *kadm.ACLBuilder) (kadm.CreateACLsResults, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateACLs", ctx, b)
	ret0, _ := ret[0].(kadm.CreateACLsResults)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateACLs indicates an expected call of CreateACLs.
func (mr *MockKafkaClientMockRecorder) CreateACLs(ctx, b interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateACLs", reflect.TypeOf((*MockKafkaClient)(nil).CreateACLs), ctx, b)
}

// CreateTopic mocks base method.
func (m *MockKafkaClient) CreateTopic(ctx context.Context, partitions int32, replicationFactor int16, configs map[string]*string, topic string) (kadm.CreateTopicResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTopic", ctx, partitions, replicationFactor, configs, topic)
	ret0, _ := ret[0].(kadm.CreateTopicResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTopic indicates an expected call of CreateTopic.
func (mr *MockKafkaClientMockRecorder) CreateTopic(ctx, partitions, replicationFactor, configs, topic interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTopic", reflect.TypeOf((*MockKafkaClient)(nil).CreateTopic), ctx, partitions, replicationFactor, configs, topic)
}

// DeleteACLs mocks base method.
func (m *MockKafkaClient) DeleteACLs(ctx context.Context, b *kadm.ACLBuilder) (kadm.DeleteACLsResults, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteACLs", ctx, b)
	ret0, _ := ret[0].(kadm.DeleteACLsResults)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteACLs indicates an expected call of DeleteACLs.
func (mr *MockKafkaClientMockRecorder) DeleteACLs(ctx, b interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteACLs", reflect.TypeOf((*MockKafkaClient)(nil).DeleteACLs), ctx, b)
}

// DeleteTopics mocks base method.
func (m *MockKafkaClient) DeleteTopics(ctx context.Context, topics ...string) (kadm.DeleteTopicResponses, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx}
	for _, a := range topics {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteTopics", varargs...)
	ret0, _ := ret[0].(kadm.DeleteTopicResponses)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteTopics indicates an expected call of DeleteTopics.
func (mr *MockKafkaClientMockRecorder) DeleteTopics(ctx interface{}, topics ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx}, topics...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTopics", reflect.TypeOf((*MockKafkaClient)(nil).DeleteTopics), varargs...)
}

// DescribeACLs mocks base method.
func (m *MockKafkaClient) DescribeACLs(ctx context.Context, b *kadm.ACLBuilder) (kadm.DescribeACLsResults, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeACLs", ctx, b)
	ret0, _ := ret[0].(kadm.DescribeACLsResults)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeACLs indicates an expected call of DescribeACLs.
func (mr *MockKafkaClientMockRecorder) DescribeACLs(ctx, b interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeACLs", reflect.TypeOf((*MockKafkaClient)(nil).DescribeACLs), ctx, b)
}

// DescribeTopicConfigs mocks base method.
func (m *MockKafkaClient) DescribeTopicConfigs(ctx context.Context, topics ...string) (kadm.ResourceConfigs, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx}
	for _, a := range topics {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTopicConfigs", varargs...)
	ret0, _ := ret[0].(kadm.ResourceConfigs)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTopicConfigs indicates an expected call of DescribeTopicConfigs.
func (mr *MockKafkaClientMockRecorder) DescribeTopicConfigs(ctx interface{}, topics ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx}, topics...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTopicConfigs", reflect.TypeOf((*MockKafkaClient)(nil).DescribeTopicConfigs), varargs...)
}

// ListTopics mocks base method.
func (m *MockKafkaClient) ListTopics(ctx context.Context, topics ...string) (kadm.TopicDetails, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx}
	for _, a := range topics {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTopics", varargs...)
	ret0, _ := ret[0].(kadm.TopicDetails)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListTopics indicates an expected call of ListTopics.
func (mr *MockKafkaClientMockRecorder) ListTopics(ctx interface{}, topics ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx}, topics...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTopics", reflect.TypeOf((*MockKafkaClient)(nil).ListTopics), varargs...)
}

// MockKmsClient is a mock of KmsClient interface.
type MockKmsClient struct {
	ctrl     *gomock.Controller
	recorder *MockKmsClientMockRecorder
}

// MockKmsClientMockRecorder is the mock recorder for MockKmsClient.
type MockKmsClientMockRecorder struct {
	mock *MockKmsClient
}

// NewMockKmsClient creates a new mock instance.
func NewMockKmsClient(ctrl *gomock.Controller) *MockKmsClient {
	mock := &MockKmsClient{ctrl: ctrl}
	mock.recorder = &MockKmsClientMockRecorder{mock}
	return mock
}

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

// CreateGrant mocks base method.
func (m *MockKmsClient) CreateGrant(ctx context.Context, params *kms.CreateGrantInput, optFns ...func(*kms.Options)) (*kms.CreateGrantOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, params}
	for _, a := range optFns {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateGrant", varargs...)
	ret0, _ := ret[0].(*kms.CreateGrantOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateGrant indicates an expected call of CreateGrant.
func (mr *MockKmsClientMockRecorder) CreateGrant(ctx, params interface{}, optFns ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, params}, optFns...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGrant", reflect.TypeOf((*MockKmsClient)(nil).CreateGrant), varargs...)
}

// RevokeGrant mocks base method.
func (m *MockKmsClient) RevokeGrant(ctx context.Context, params *kms.RevokeGrantInput, optFns ...func(*kms.Options)) (*kms.RevokeGrantOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, params}
	for _, a := range optFns {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RevokeGrant", varargs...)
	ret0, _ := ret[0].(*kms.RevokeGrantOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RevokeGrant indicates an expected call of RevokeGrant.
func (mr *MockKmsClientMockRecorder) RevokeGrant(ctx, params interface{}, optFns ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, params}, optFns...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeGrant", reflect.TypeOf((*MockKmsClient)(nil).RevokeGrant), varargs...)
}

// MockSecretsManagerClient is a mock of SecretsManagerClient interface.
type MockSecretsManagerClient struct {
	ctrl     *gomock.Controller
	recorder *MockSecretsManagerClientMockRecorder
}

// MockSecretsManagerClientMockRecorder is the mock recorder for MockSecretsManagerClient.
type MockSecretsManagerClientMockRecorder struct {
	mock *MockSecretsManagerClient
}

// NewMockSecretsManagerClient creates a new mock instance.
func NewMockSecretsManagerClient(ctrl *gomock.Controller) *MockSecretsManagerClient {
	mock := &MockSecretsManagerClient{ctrl: ctrl}
	mock.recorder = &MockSecretsManagerClientMockRecorder{mock}
	return mock
}

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

// CreateSecret mocks base method.
func (m *MockSecretsManagerClient) CreateSecret(ctx context.Context, params *secretsmanager.CreateSecretInput, optFns ...func(*secretsmanager.Options)) (*secretsmanager.CreateSecretOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, params}
	for _, a := range optFns {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateSecret", varargs...)
	ret0, _ := ret[0].(*secretsmanager.CreateSecretOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateSecret indicates an expected call of CreateSecret.
func (mr *MockSecretsManagerClientMockRecorder) CreateSecret(ctx, params interface{}, optFns ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, params}, optFns...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecret", reflect.TypeOf((*MockSecretsManagerClient)(nil).CreateSecret), varargs...)
}

// DeleteSecret mocks base method.
func (m *MockSecretsManagerClient) DeleteSecret(ctx context.Context, params *secretsmanager.DeleteSecretInput, optFns ...func(*secretsmanager.Options)) (*secretsmanager.DeleteSecretOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, params}
	for _, a := range optFns {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteSecret", varargs...)
	ret0, _ := ret[0].(*secretsmanager.DeleteSecretOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteSecret indicates an expected call of DeleteSecret.
func (mr *MockSecretsManagerClientMockRecorder) DeleteSecret(ctx, params interface{}, optFns ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, params}, optFns...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecret", reflect.TypeOf((*MockSecretsManagerClient)(nil).DeleteSecret), varargs...)
}

// DescribeSecret mocks base method.
func (m *MockSecretsManagerClient) DescribeSecret(ctx context.Context, params *secretsmanager.DescribeSecretInput, optFns ...func(*secretsmanager.Options)) (*secretsmanager.DescribeSecretOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, params}
	for _, a := range optFns {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeSecret", varargs...)
	ret0, _ := ret[0].(*secretsmanager.DescribeSecretOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeSecret indicates an expected call of DescribeSecret.
func (mr *MockSecretsManagerClientMockRecorder) DescribeSecret(ctx, params interface{}, optFns ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, params}, optFns...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecret", reflect.TypeOf((*MockSecretsManagerClient)(nil).DescribeSecret), varargs...)
}

// ListSecrets mocks base method.
func (m *MockSecretsManagerClient) ListSecrets(ctx context.Context, params *secretsmanager.ListSecretsInput, optFns ...func(*secretsmanager.Options)) (*secretsmanager.ListSecretsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, params}
	for _, a := range optFns {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListSecrets", varargs...)
	ret0, _ := ret[0].(*secretsmanager.ListSecretsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListSecrets indicates an expected call of ListSecrets.
func (mr *MockSecretsManagerClientMockRecorder) ListSecrets(ctx, params interface{}, optFns ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, params}, optFns...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSecrets", reflect.TypeOf((*MockSecretsManagerClient)(nil).ListSecrets), varargs...)
}

// PutResourcePolicy mocks base method.
func (m *MockSecretsManagerClient) PutResourcePolicy(ctx context.Context, params *secretsmanager.PutResourcePolicyInput, optFns ...func(*secretsmanager.Options)) (*secretsmanager.PutResourcePolicyOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, params}
	for _, a := range optFns {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PutResourcePolicy", varargs...)
	ret0, _ := ret[0].(*secretsmanager.PutResourcePolicyOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutResourcePolicy indicates an expected call of PutResourcePolicy.
func (mr *MockSecretsManagerClientMockRecorder) PutResourcePolicy(ctx, params interface{}, optFns ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, params}, optFns...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutResourcePolicy", reflect.TypeOf((*MockSecretsManagerClient)(nil).PutResourcePolicy), varargs...)
}

// MockMskClient is a mock of MskClient interface.
type MockMskClient struct {
	ctrl     *gomock.Controller
	recorder *MockMskClientMockRecorder
}

// MockMskClientMockRecorder is the mock recorder for MockMskClient.
type MockMskClientMockRecorder struct {
	mock *MockMskClient
}

// NewMockMskClient creates a new mock instance.
func NewMockMskClient(ctrl *gomock.Controller) *MockMskClient {
	mock := &MockMskClient{ctrl: ctrl}
	mock.recorder = &MockMskClientMockRecorder{mock}
	return mock
}

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

// BatchAssociateScramSecret mocks base method.
func (m *MockMskClient) BatchAssociateScramSecret(ctx context.Context, params *kafka.BatchAssociateScramSecretInput, optFns ...func(*kafka.Options)) (*kafka.BatchAssociateScramSecretOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, params}
	for _, a := range optFns {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BatchAssociateScramSecret", varargs...)
	ret0, _ := ret[0].(*kafka.BatchAssociateScramSecretOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchAssociateScramSecret indicates an expected call of BatchAssociateScramSecret.
func (mr *MockMskClientMockRecorder) BatchAssociateScramSecret(ctx, params interface{}, optFns ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, params}, optFns...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchAssociateScramSecret", reflect.TypeOf((*MockMskClient)(nil).BatchAssociateScramSecret), varargs...)
}

// BatchDisassociateScramSecret mocks base method.
func (m *MockMskClient) BatchDisassociateScramSecret(ctx context.Context, params *kafka.BatchDisassociateScramSecretInput, optFns ...func(*kafka.Options)) (*kafka.BatchDisassociateScramSecretOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, params}
	for _, a := range optFns {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BatchDisassociateScramSecret", varargs...)
	ret0, _ := ret[0].(*kafka.BatchDisassociateScramSecretOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BatchDisassociateScramSecret indicates an expected call of BatchDisassociateScramSecret.
func (mr *MockMskClientMockRecorder) BatchDisassociateScramSecret(ctx, params interface{}, optFns ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, params}, optFns...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchDisassociateScramSecret", reflect.TypeOf((*MockMskClient)(nil).BatchDisassociateScramSecret), varargs...)
}

// DescribeCluster mocks base method.
func (m *MockMskClient) DescribeCluster(ctx context.Context, params *kafka.DescribeClusterInput, optFns ...func(*kafka.Options)) (*kafka.DescribeClusterOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, params}
	for _, a := range optFns {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeCluster", varargs...)
	ret0, _ := ret[0].(*kafka.DescribeClusterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeCluster indicates an expected call of DescribeCluster.
func (mr *MockMskClientMockRecorder) DescribeCluster(ctx, params interface{}, optFns ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, params}, optFns...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCluster", reflect.TypeOf((*MockMskClient)(nil).DescribeCluster), varargs...)
}

// GetBootstrapBrokers mocks base method.
func (m *MockMskClient) GetBootstrapBrokers(ctx context.Context, params *kafka.GetBootstrapBrokersInput, optFns ...func(*kafka.Options)) (*kafka.GetBootstrapBrokersOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, params}
	for _, a := range optFns {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetBootstrapBrokers", varargs...)
	ret0, _ := ret[0].(*kafka.GetBootstrapBrokersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBootstrapBrokers indicates an expected call of GetBootstrapBrokers.
func (mr *MockMskClientMockRecorder) GetBootstrapBrokers(ctx, params interface{}, optFns ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, params}, optFns...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBootstrapBrokers", reflect.TypeOf((*MockMskClient)(nil).GetBootstrapBrokers), varargs...)
}