tasks/api/adminservicemock/v1/service_grpc.pb.mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: api/adminservice/v1/service_grpc.pb.go
//
// Generated by this command:
//
//	mockgen -package adminservicemock -source api/adminservice/v1/service_grpc.pb.go -destination api/adminservicemock/v1/service_grpc.pb.mock.go
//

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

import (
	context "context"
	reflect "reflect"

	adminservice "go.temporal.io/server/api/adminservice/v1"
	gomock "go.uber.org/mock/gomock"
	grpc "google.golang.org/grpc"
	metadata "google.golang.org/grpc/metadata"
)

// MockAdminServiceClient is a mock of AdminServiceClient interface.
type MockAdminServiceClient struct {
	ctrl     *gomock.Controller
	recorder *MockAdminServiceClientMockRecorder
	isgomock struct{}
}

// MockAdminServiceClientMockRecorder is the mock recorder for MockAdminServiceClient.
type MockAdminServiceClientMockRecorder struct {
	mock *MockAdminServiceClient
}

// NewMockAdminServiceClient creates a new mock instance.
func NewMockAdminServiceClient(ctrl *gomock.Controller) *MockAdminServiceClient {
	mock := &MockAdminServiceClient{ctrl: ctrl}
	mock.recorder = &MockAdminServiceClientMockRecorder{mock}
	return mock
}

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

// AddOrUpdateRemoteCluster mocks base method.
func (m *MockAdminServiceClient) AddOrUpdateRemoteCluster(ctx context.Context, in *adminservice.AddOrUpdateRemoteClusterRequest, opts ...grpc.CallOption) (*adminservice.AddOrUpdateRemoteClusterResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddOrUpdateRemoteCluster", varargs...)
	ret0, _ := ret[0].(*adminservice.AddOrUpdateRemoteClusterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddOrUpdateRemoteCluster indicates an expected call of AddOrUpdateRemoteCluster.
func (mr *MockAdminServiceClientMockRecorder) AddOrUpdateRemoteCluster(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddOrUpdateRemoteCluster", reflect.TypeOf((*MockAdminServiceClient)(nil).AddOrUpdateRemoteCluster), varargs...)
}

// AddSearchAttributes mocks base method.
func (m *MockAdminServiceClient) AddSearchAttributes(ctx context.Context, in *adminservice.AddSearchAttributesRequest, opts ...grpc.CallOption) (*adminservice.AddSearchAttributesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddSearchAttributes", varargs...)
	ret0, _ := ret[0].(*adminservice.AddSearchAttributesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddSearchAttributes indicates an expected call of AddSearchAttributes.
func (mr *MockAdminServiceClientMockRecorder) AddSearchAttributes(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSearchAttributes", reflect.TypeOf((*MockAdminServiceClient)(nil).AddSearchAttributes), varargs...)
}

// AddTasks mocks base method.
func (m *MockAdminServiceClient) AddTasks(ctx context.Context, in *adminservice.AddTasksRequest, opts ...grpc.CallOption) (*adminservice.AddTasksResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AddTasks", varargs...)
	ret0, _ := ret[0].(*adminservice.AddTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddTasks indicates an expected call of AddTasks.
func (mr *MockAdminServiceClientMockRecorder) AddTasks(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTasks", reflect.TypeOf((*MockAdminServiceClient)(nil).AddTasks), varargs...)
}

// CancelDLQJob mocks base method.
func (m *MockAdminServiceClient) CancelDLQJob(ctx context.Context, in *adminservice.CancelDLQJobRequest, opts ...grpc.CallOption) (*adminservice.CancelDLQJobResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CancelDLQJob", varargs...)
	ret0, _ := ret[0].(*adminservice.CancelDLQJobResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CancelDLQJob indicates an expected call of CancelDLQJob.
func (mr *MockAdminServiceClientMockRecorder) CancelDLQJob(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelDLQJob", reflect.TypeOf((*MockAdminServiceClient)(nil).CancelDLQJob), varargs...)
}

// CloseShard mocks base method.
func (m *MockAdminServiceClient) CloseShard(ctx context.Context, in *adminservice.CloseShardRequest, opts ...grpc.CallOption) (*adminservice.CloseShardResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CloseShard", varargs...)
	ret0, _ := ret[0].(*adminservice.CloseShardResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CloseShard indicates an expected call of CloseShard.
func (mr *MockAdminServiceClientMockRecorder) CloseShard(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseShard", reflect.TypeOf((*MockAdminServiceClient)(nil).CloseShard), varargs...)
}

// DeepHealthCheck mocks base method.
func (m *MockAdminServiceClient) DeepHealthCheck(ctx context.Context, in *adminservice.DeepHealthCheckRequest, opts ...grpc.CallOption) (*adminservice.DeepHealthCheckResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeepHealthCheck", varargs...)
	ret0, _ := ret[0].(*adminservice.DeepHealthCheckResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeepHealthCheck indicates an expected call of DeepHealthCheck.
func (mr *MockAdminServiceClientMockRecorder) DeepHealthCheck(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeepHealthCheck", reflect.TypeOf((*MockAdminServiceClient)(nil).DeepHealthCheck), varargs...)
}

// DeleteWorkflowExecution mocks base method.
func (m *MockAdminServiceClient) DeleteWorkflowExecution(ctx context.Context, in *adminservice.DeleteWorkflowExecutionRequest, opts ...grpc.CallOption) (*adminservice.DeleteWorkflowExecutionResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteWorkflowExecution", varargs...)
	ret0, _ := ret[0].(*adminservice.DeleteWorkflowExecutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteWorkflowExecution indicates an expected call of DeleteWorkflowExecution.
func (mr *MockAdminServiceClientMockRecorder) DeleteWorkflowExecution(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWorkflowExecution", reflect.TypeOf((*MockAdminServiceClient)(nil).DeleteWorkflowExecution), varargs...)
}

// DescribeCluster mocks base method.
func (m *MockAdminServiceClient) DescribeCluster(ctx context.Context, in *adminservice.DescribeClusterRequest, opts ...grpc.CallOption) (*adminservice.DescribeClusterResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeCluster", varargs...)
	ret0, _ := ret[0].(*adminservice.DescribeClusterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeCluster indicates an expected call of DescribeCluster.
func (mr *MockAdminServiceClientMockRecorder) DescribeCluster(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCluster", reflect.TypeOf((*MockAdminServiceClient)(nil).DescribeCluster), varargs...)
}

// DescribeDLQJob mocks base method.
func (m *MockAdminServiceClient) DescribeDLQJob(ctx context.Context, in *adminservice.DescribeDLQJobRequest, opts ...grpc.CallOption) (*adminservice.DescribeDLQJobResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeDLQJob", varargs...)
	ret0, _ := ret[0].(*adminservice.DescribeDLQJobResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeDLQJob indicates an expected call of DescribeDLQJob.
func (mr *MockAdminServiceClientMockRecorder) DescribeDLQJob(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDLQJob", reflect.TypeOf((*MockAdminServiceClient)(nil).DescribeDLQJob), varargs...)
}

// DescribeHistoryHost mocks base method.
func (m *MockAdminServiceClient) DescribeHistoryHost(ctx context.Context, in *adminservice.DescribeHistoryHostRequest, opts ...grpc.CallOption) (*adminservice.DescribeHistoryHostResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeHistoryHost", varargs...)
	ret0, _ := ret[0].(*adminservice.DescribeHistoryHostResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeHistoryHost indicates an expected call of DescribeHistoryHost.
func (mr *MockAdminServiceClientMockRecorder) DescribeHistoryHost(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHistoryHost", reflect.TypeOf((*MockAdminServiceClient)(nil).DescribeHistoryHost), varargs...)
}

// DescribeMutableState mocks base method.
func (m *MockAdminServiceClient) DescribeMutableState(ctx context.Context, in *adminservice.DescribeMutableStateRequest, opts ...grpc.CallOption) (*adminservice.DescribeMutableStateResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeMutableState", varargs...)
	ret0, _ := ret[0].(*adminservice.DescribeMutableStateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeMutableState indicates an expected call of DescribeMutableState.
func (mr *MockAdminServiceClientMockRecorder) DescribeMutableState(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMutableState", reflect.TypeOf((*MockAdminServiceClient)(nil).DescribeMutableState), varargs...)
}

// DescribeTaskQueuePartition mocks base method.
func (m *MockAdminServiceClient) DescribeTaskQueuePartition(ctx context.Context, in *adminservice.DescribeTaskQueuePartitionRequest, opts ...grpc.CallOption) (*adminservice.DescribeTaskQueuePartitionResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeTaskQueuePartition", varargs...)
	ret0, _ := ret[0].(*adminservice.DescribeTaskQueuePartitionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTaskQueuePartition indicates an expected call of DescribeTaskQueuePartition.
func (mr *MockAdminServiceClientMockRecorder) DescribeTaskQueuePartition(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTaskQueuePartition", reflect.TypeOf((*MockAdminServiceClient)(nil).DescribeTaskQueuePartition), varargs...)
}

// ForceUnloadTaskQueuePartition mocks base method.
func (m *MockAdminServiceClient) ForceUnloadTaskQueuePartition(ctx context.Context, in *adminservice.ForceUnloadTaskQueuePartitionRequest, opts ...grpc.CallOption) (*adminservice.ForceUnloadTaskQueuePartitionResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ForceUnloadTaskQueuePartition", varargs...)
	ret0, _ := ret[0].(*adminservice.ForceUnloadTaskQueuePartitionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ForceUnloadTaskQueuePartition indicates an expected call of ForceUnloadTaskQueuePartition.
func (mr *MockAdminServiceClientMockRecorder) ForceUnloadTaskQueuePartition(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForceUnloadTaskQueuePartition", reflect.TypeOf((*MockAdminServiceClient)(nil).ForceUnloadTaskQueuePartition), varargs...)
}

// GenerateLastHistoryReplicationTasks mocks base method.
func (m *MockAdminServiceClient) GenerateLastHistoryReplicationTasks(ctx context.Context, in *adminservice.GenerateLastHistoryReplicationTasksRequest, opts ...grpc.CallOption) (*adminservice.GenerateLastHistoryReplicationTasksResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GenerateLastHistoryReplicationTasks", varargs...)
	ret0, _ := ret[0].(*adminservice.GenerateLastHistoryReplicationTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GenerateLastHistoryReplicationTasks indicates an expected call of GenerateLastHistoryReplicationTasks.
func (mr *MockAdminServiceClientMockRecorder) GenerateLastHistoryReplicationTasks(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateLastHistoryReplicationTasks", reflect.TypeOf((*MockAdminServiceClient)(nil).GenerateLastHistoryReplicationTasks), varargs...)
}

// GetDLQMessages mocks base method.
func (m *MockAdminServiceClient) GetDLQMessages(ctx context.Context, in *adminservice.GetDLQMessagesRequest, opts ...grpc.CallOption) (*adminservice.GetDLQMessagesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetDLQMessages", varargs...)
	ret0, _ := ret[0].(*adminservice.GetDLQMessagesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDLQMessages indicates an expected call of GetDLQMessages.
func (mr *MockAdminServiceClientMockRecorder) GetDLQMessages(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDLQMessages", reflect.TypeOf((*MockAdminServiceClient)(nil).GetDLQMessages), varargs...)
}

// GetDLQReplicationMessages mocks base method.
func (m *MockAdminServiceClient) GetDLQReplicationMessages(ctx context.Context, in *adminservice.GetDLQReplicationMessagesRequest, opts ...grpc.CallOption) (*adminservice.GetDLQReplicationMessagesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetDLQReplicationMessages", varargs...)
	ret0, _ := ret[0].(*adminservice.GetDLQReplicationMessagesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDLQReplicationMessages indicates an expected call of GetDLQReplicationMessages.
func (mr *MockAdminServiceClientMockRecorder) GetDLQReplicationMessages(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDLQReplicationMessages", reflect.TypeOf((*MockAdminServiceClient)(nil).GetDLQReplicationMessages), varargs...)
}

// GetDLQTasks mocks base method.
func (m *MockAdminServiceClient) GetDLQTasks(ctx context.Context, in *adminservice.GetDLQTasksRequest, opts ...grpc.CallOption) (*adminservice.GetDLQTasksResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetDLQTasks", varargs...)
	ret0, _ := ret[0].(*adminservice.GetDLQTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDLQTasks indicates an expected call of GetDLQTasks.
func (mr *MockAdminServiceClientMockRecorder) GetDLQTasks(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDLQTasks", reflect.TypeOf((*MockAdminServiceClient)(nil).GetDLQTasks), varargs...)
}

// GetNamespace mocks base method.
func (m *MockAdminServiceClient) GetNamespace(ctx context.Context, in *adminservice.GetNamespaceRequest, opts ...grpc.CallOption) (*adminservice.GetNamespaceResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetNamespace", varargs...)
	ret0, _ := ret[0].(*adminservice.GetNamespaceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNamespace indicates an expected call of GetNamespace.
func (mr *MockAdminServiceClientMockRecorder) GetNamespace(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespace", reflect.TypeOf((*MockAdminServiceClient)(nil).GetNamespace), varargs...)
}

// GetNamespaceReplicationMessages mocks base method.
func (m *MockAdminServiceClient) GetNamespaceReplicationMessages(ctx context.Context, in *adminservice.GetNamespaceReplicationMessagesRequest, opts ...grpc.CallOption) (*adminservice.GetNamespaceReplicationMessagesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetNamespaceReplicationMessages", varargs...)
	ret0, _ := ret[0].(*adminservice.GetNamespaceReplicationMessagesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNamespaceReplicationMessages indicates an expected call of GetNamespaceReplicationMessages.
func (mr *MockAdminServiceClientMockRecorder) GetNamespaceReplicationMessages(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespaceReplicationMessages", reflect.TypeOf((*MockAdminServiceClient)(nil).GetNamespaceReplicationMessages), varargs...)
}

// GetReplicationMessages mocks base method.
func (m *MockAdminServiceClient) GetReplicationMessages(ctx context.Context, in *adminservice.GetReplicationMessagesRequest, opts ...grpc.CallOption) (*adminservice.GetReplicationMessagesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetReplicationMessages", varargs...)
	ret0, _ := ret[0].(*adminservice.GetReplicationMessagesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetReplicationMessages indicates an expected call of GetReplicationMessages.
func (mr *MockAdminServiceClientMockRecorder) GetReplicationMessages(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReplicationMessages", reflect.TypeOf((*MockAdminServiceClient)(nil).GetReplicationMessages), varargs...)
}

// GetSearchAttributes mocks base method.
func (m *MockAdminServiceClient) GetSearchAttributes(ctx context.Context, in *adminservice.GetSearchAttributesRequest, opts ...grpc.CallOption) (*adminservice.GetSearchAttributesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSearchAttributes", varargs...)
	ret0, _ := ret[0].(*adminservice.GetSearchAttributesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSearchAttributes indicates an expected call of GetSearchAttributes.
func (mr *MockAdminServiceClientMockRecorder) GetSearchAttributes(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSearchAttributes", reflect.TypeOf((*MockAdminServiceClient)(nil).GetSearchAttributes), varargs...)
}

// GetShard mocks base method.
func (m *MockAdminServiceClient) GetShard(ctx context.Context, in *adminservice.GetShardRequest, opts ...grpc.CallOption) (*adminservice.GetShardResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetShard", varargs...)
	ret0, _ := ret[0].(*adminservice.GetShardResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetShard indicates an expected call of GetShard.
func (mr *MockAdminServiceClientMockRecorder) GetShard(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetShard", reflect.TypeOf((*MockAdminServiceClient)(nil).GetShard), varargs...)
}

// GetTaskQueueTasks mocks base method.
func (m *MockAdminServiceClient) GetTaskQueueTasks(ctx context.Context, in *adminservice.GetTaskQueueTasksRequest, opts ...grpc.CallOption) (*adminservice.GetTaskQueueTasksResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetTaskQueueTasks", varargs...)
	ret0, _ := ret[0].(*adminservice.GetTaskQueueTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTaskQueueTasks indicates an expected call of GetTaskQueueTasks.
func (mr *MockAdminServiceClientMockRecorder) GetTaskQueueTasks(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTaskQueueTasks", reflect.TypeOf((*MockAdminServiceClient)(nil).GetTaskQueueTasks), varargs...)
}

// GetWorkflowExecutionRawHistory mocks base method.
func (m *MockAdminServiceClient) GetWorkflowExecutionRawHistory(ctx context.Context, in *adminservice.GetWorkflowExecutionRawHistoryRequest, opts ...grpc.CallOption) (*adminservice.GetWorkflowExecutionRawHistoryResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetWorkflowExecutionRawHistory", varargs...)
	ret0, _ := ret[0].(*adminservice.GetWorkflowExecutionRawHistoryResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkflowExecutionRawHistory indicates an expected call of GetWorkflowExecutionRawHistory.
func (mr *MockAdminServiceClientMockRecorder) GetWorkflowExecutionRawHistory(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowExecutionRawHistory", reflect.TypeOf((*MockAdminServiceClient)(nil).GetWorkflowExecutionRawHistory), varargs...)
}

// GetWorkflowExecutionRawHistoryV2 mocks base method.
func (m *MockAdminServiceClient) GetWorkflowExecutionRawHistoryV2(ctx context.Context, in *adminservice.GetWorkflowExecutionRawHistoryV2Request, opts ...grpc.CallOption) (*adminservice.GetWorkflowExecutionRawHistoryV2Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetWorkflowExecutionRawHistoryV2", varargs...)
	ret0, _ := ret[0].(*adminservice.GetWorkflowExecutionRawHistoryV2Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWorkflowExecutionRawHistoryV2 indicates an expected call of GetWorkflowExecutionRawHistoryV2.
func (mr *MockAdminServiceClientMockRecorder) GetWorkflowExecutionRawHistoryV2(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWorkflowExecutionRawHistoryV2", reflect.TypeOf((*MockAdminServiceClient)(nil).GetWorkflowExecutionRawHistoryV2), varargs...)
}

// ImportWorkflowExecution mocks base method.
func (m *MockAdminServiceClient) ImportWorkflowExecution(ctx context.Context, in *adminservice.ImportWorkflowExecutionRequest, opts ...grpc.CallOption) (*adminservice.ImportWorkflowExecutionResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ImportWorkflowExecution", varargs...)
	ret0, _ := ret[0].(*adminservice.ImportWorkflowExecutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ImportWorkflowExecution indicates an expected call of ImportWorkflowExecution.
func (mr *MockAdminServiceClientMockRecorder) ImportWorkflowExecution(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportWorkflowExecution", reflect.TypeOf((*MockAdminServiceClient)(nil).ImportWorkflowExecution), varargs...)
}

// ListClusterMembers mocks base method.
func (m *MockAdminServiceClient) ListClusterMembers(ctx context.Context, in *adminservice.ListClusterMembersRequest, opts ...grpc.CallOption) (*adminservice.ListClusterMembersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListClusterMembers", varargs...)
	ret0, _ := ret[0].(*adminservice.ListClusterMembersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListClusterMembers indicates an expected call of ListClusterMembers.
func (mr *MockAdminServiceClientMockRecorder) ListClusterMembers(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClusterMembers", reflect.TypeOf((*MockAdminServiceClient)(nil).ListClusterMembers), varargs...)
}

// ListClusters mocks base method.
func (m *MockAdminServiceClient) ListClusters(ctx context.Context, in *adminservice.ListClustersRequest, opts ...grpc.CallOption) (*adminservice.ListClustersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListClusters", varargs...)
	ret0, _ := ret[0].(*adminservice.ListClustersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListClusters indicates an expected call of ListClusters.
func (mr *MockAdminServiceClientMockRecorder) ListClusters(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClusters", reflect.TypeOf((*MockAdminServiceClient)(nil).ListClusters), varargs...)
}

// ListHistoryTasks mocks base method.
func (m *MockAdminServiceClient) ListHistoryTasks(ctx context.Context, in *adminservice.ListHistoryTasksRequest, opts ...grpc.CallOption) (*adminservice.ListHistoryTasksResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListHistoryTasks", varargs...)
	ret0, _ := ret[0].(*adminservice.ListHistoryTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListHistoryTasks indicates an expected call of ListHistoryTasks.
func (mr *MockAdminServiceClientMockRecorder) ListHistoryTasks(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHistoryTasks", reflect.TypeOf((*MockAdminServiceClient)(nil).ListHistoryTasks), varargs...)
}

// ListQueues mocks base method.
func (m *MockAdminServiceClient) ListQueues(ctx context.Context, in *adminservice.ListQueuesRequest, opts ...grpc.CallOption) (*adminservice.ListQueuesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListQueues", varargs...)
	ret0, _ := ret[0].(*adminservice.ListQueuesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListQueues indicates an expected call of ListQueues.
func (mr *MockAdminServiceClientMockRecorder) ListQueues(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueues", reflect.TypeOf((*MockAdminServiceClient)(nil).ListQueues), varargs...)
}

// MergeDLQMessages mocks base method.
func (m *MockAdminServiceClient) MergeDLQMessages(ctx context.Context, in *adminservice.MergeDLQMessagesRequest, opts ...grpc.CallOption) (*adminservice.MergeDLQMessagesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "MergeDLQMessages", varargs...)
	ret0, _ := ret[0].(*adminservice.MergeDLQMessagesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MergeDLQMessages indicates an expected call of MergeDLQMessages.
func (mr *MockAdminServiceClientMockRecorder) MergeDLQMessages(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MergeDLQMessages", reflect.TypeOf((*MockAdminServiceClient)(nil).MergeDLQMessages), varargs...)
}

// MergeDLQTasks mocks base method.
func (m *MockAdminServiceClient) MergeDLQTasks(ctx context.Context, in *adminservice.MergeDLQTasksRequest, opts ...grpc.CallOption) (*adminservice.MergeDLQTasksResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "MergeDLQTasks", varargs...)
	ret0, _ := ret[0].(*adminservice.MergeDLQTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MergeDLQTasks indicates an expected call of MergeDLQTasks.
func (mr *MockAdminServiceClientMockRecorder) MergeDLQTasks(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MergeDLQTasks", reflect.TypeOf((*MockAdminServiceClient)(nil).MergeDLQTasks), varargs...)
}

// PurgeDLQMessages mocks base method.
func (m *MockAdminServiceClient) PurgeDLQMessages(ctx context.Context, in *adminservice.PurgeDLQMessagesRequest, opts ...grpc.CallOption) (*adminservice.PurgeDLQMessagesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PurgeDLQMessages", varargs...)
	ret0, _ := ret[0].(*adminservice.PurgeDLQMessagesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PurgeDLQMessages indicates an expected call of PurgeDLQMessages.
func (mr *MockAdminServiceClientMockRecorder) PurgeDLQMessages(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurgeDLQMessages", reflect.TypeOf((*MockAdminServiceClient)(nil).PurgeDLQMessages), varargs...)
}

// PurgeDLQTasks mocks base method.
func (m *MockAdminServiceClient) PurgeDLQTasks(ctx context.Context, in *adminservice.PurgeDLQTasksRequest, opts ...grpc.CallOption) (*adminservice.PurgeDLQTasksResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PurgeDLQTasks", varargs...)
	ret0, _ := ret[0].(*adminservice.PurgeDLQTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PurgeDLQTasks indicates an expected call of PurgeDLQTasks.
func (mr *MockAdminServiceClientMockRecorder) PurgeDLQTasks(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurgeDLQTasks", reflect.TypeOf((*MockAdminServiceClient)(nil).PurgeDLQTasks), varargs...)
}

// ReapplyEvents mocks base method.
func (m *MockAdminServiceClient) ReapplyEvents(ctx context.Context, in *adminservice.ReapplyEventsRequest, opts ...grpc.CallOption) (*adminservice.ReapplyEventsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReapplyEvents", varargs...)
	ret0, _ := ret[0].(*adminservice.ReapplyEventsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReapplyEvents indicates an expected call of ReapplyEvents.
func (mr *MockAdminServiceClientMockRecorder) ReapplyEvents(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReapplyEvents", reflect.TypeOf((*MockAdminServiceClient)(nil).ReapplyEvents), varargs...)
}

// RebuildMutableState mocks base method.
func (m *MockAdminServiceClient) RebuildMutableState(ctx context.Context, in *adminservice.RebuildMutableStateRequest, opts ...grpc.CallOption) (*adminservice.RebuildMutableStateResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RebuildMutableState", varargs...)
	ret0, _ := ret[0].(*adminservice.RebuildMutableStateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RebuildMutableState indicates an expected call of RebuildMutableState.
func (mr *MockAdminServiceClientMockRecorder) RebuildMutableState(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebuildMutableState", reflect.TypeOf((*MockAdminServiceClient)(nil).RebuildMutableState), varargs...)
}

// RefreshWorkflowTasks mocks base method.
func (m *MockAdminServiceClient) RefreshWorkflowTasks(ctx context.Context, in *adminservice.RefreshWorkflowTasksRequest, opts ...grpc.CallOption) (*adminservice.RefreshWorkflowTasksResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RefreshWorkflowTasks", varargs...)
	ret0, _ := ret[0].(*adminservice.RefreshWorkflowTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RefreshWorkflowTasks indicates an expected call of RefreshWorkflowTasks.
func (mr *MockAdminServiceClientMockRecorder) RefreshWorkflowTasks(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RefreshWorkflowTasks", reflect.TypeOf((*MockAdminServiceClient)(nil).RefreshWorkflowTasks), varargs...)
}

// RemoveRemoteCluster mocks base method.
func (m *MockAdminServiceClient) RemoveRemoteCluster(ctx context.Context, in *adminservice.RemoveRemoteClusterRequest, opts ...grpc.CallOption) (*adminservice.RemoveRemoteClusterResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RemoveRemoteCluster", varargs...)
	ret0, _ := ret[0].(*adminservice.RemoveRemoteClusterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveRemoteCluster indicates an expected call of RemoveRemoteCluster.
func (mr *MockAdminServiceClientMockRecorder) RemoveRemoteCluster(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveRemoteCluster", reflect.TypeOf((*MockAdminServiceClient)(nil).RemoveRemoteCluster), varargs...)
}

// RemoveSearchAttributes mocks base method.
func (m *MockAdminServiceClient) RemoveSearchAttributes(ctx context.Context, in *adminservice.RemoveSearchAttributesRequest, opts ...grpc.CallOption) (*adminservice.RemoveSearchAttributesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RemoveSearchAttributes", varargs...)
	ret0, _ := ret[0].(*adminservice.RemoveSearchAttributesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveSearchAttributes indicates an expected call of RemoveSearchAttributes.
func (mr *MockAdminServiceClientMockRecorder) RemoveSearchAttributes(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveSearchAttributes", reflect.TypeOf((*MockAdminServiceClient)(nil).RemoveSearchAttributes), varargs...)
}

// RemoveTask mocks base method.
func (m *MockAdminServiceClient) RemoveTask(ctx context.Context, in *adminservice.RemoveTaskRequest, opts ...grpc.CallOption) (*adminservice.RemoveTaskResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RemoveTask", varargs...)
	ret0, _ := ret[0].(*adminservice.RemoveTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveTask indicates an expected call of RemoveTask.
func (mr *MockAdminServiceClientMockRecorder) RemoveTask(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTask", reflect.TypeOf((*MockAdminServiceClient)(nil).RemoveTask), varargs...)
}

// ResendReplicationTasks mocks base method.
func (m *MockAdminServiceClient) ResendReplicationTasks(ctx context.Context, in *adminservice.ResendReplicationTasksRequest, opts ...grpc.CallOption) (*adminservice.ResendReplicationTasksResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResendReplicationTasks", varargs...)
	ret0, _ := ret[0].(*adminservice.ResendReplicationTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ResendReplicationTasks indicates an expected call of ResendReplicationTasks.
func (mr *MockAdminServiceClientMockRecorder) ResendReplicationTasks(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResendReplicationTasks", reflect.TypeOf((*MockAdminServiceClient)(nil).ResendReplicationTasks), varargs...)
}

// StartAdminBatchOperation mocks base method.
func (m *MockAdminServiceClient) StartAdminBatchOperation(ctx context.Context, in *adminservice.StartAdminBatchOperationRequest, opts ...grpc.CallOption) (*adminservice.StartAdminBatchOperationResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StartAdminBatchOperation", varargs...)
	ret0, _ := ret[0].(*adminservice.StartAdminBatchOperationResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StartAdminBatchOperation indicates an expected call of StartAdminBatchOperation.
func (mr *MockAdminServiceClientMockRecorder) StartAdminBatchOperation(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartAdminBatchOperation", reflect.TypeOf((*MockAdminServiceClient)(nil).StartAdminBatchOperation), varargs...)
}

// StreamWorkflowReplicationMessages mocks base method.
func (m *MockAdminServiceClient) StreamWorkflowReplicationMessages(ctx context.Context, opts ...grpc.CallOption) (adminservice.AdminService_StreamWorkflowReplicationMessagesClient, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StreamWorkflowReplicationMessages", varargs...)
	ret0, _ := ret[0].(adminservice.AdminService_StreamWorkflowReplicationMessagesClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// StreamWorkflowReplicationMessages indicates an expected call of StreamWorkflowReplicationMessages.
func (mr *MockAdminServiceClientMockRecorder) StreamWorkflowReplicationMessages(ctx any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamWorkflowReplicationMessages", reflect.TypeOf((*MockAdminServiceClient)(nil).StreamWorkflowReplicationMessages), varargs...)
}

// SyncWorkflowState mocks base method.
func (m *MockAdminServiceClient) SyncWorkflowState(ctx context.Context, in *adminservice.SyncWorkflowStateRequest, opts ...grpc.CallOption) (*adminservice.SyncWorkflowStateResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, in}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SyncWorkflowState", varargs...)
	ret0, _ := ret[0].(*adminservice.SyncWorkflowStateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SyncWorkflowState indicates an expected call of SyncWorkflowState.
func (mr *MockAdminServiceClientMockRecorder) SyncWorkflowState(ctx, in any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, in}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncWorkflowState", reflect.TypeOf((*MockAdminServiceClient)(nil).SyncWorkflowState), varargs...)
}

// MockAdminService_StreamWorkflowReplicationMessagesClient is a mock of AdminService_StreamWorkflowReplicationMessagesClient interface.
type MockAdminService_StreamWorkflowReplicationMessagesClient struct {
	ctrl     *gomock.Controller
	recorder *MockAdminService_StreamWorkflowReplicationMessagesClientMockRecorder
	isgomock struct{}
}

// MockAdminService_StreamWorkflowReplicationMessagesClientMockRecorder is the mock recorder for MockAdminService_StreamWorkflowReplicationMessagesClient.
type MockAdminService_StreamWorkflowReplicationMessagesClientMockRecorder struct {
	mock *MockAdminService_StreamWorkflowReplicationMessagesClient
}

// NewMockAdminService_StreamWorkflowReplicationMessagesClient creates a new mock instance.
func NewMockAdminService_StreamWorkflowReplicationMessagesClient(ctrl *gomock.Controller) *MockAdminService_StreamWorkflowReplicationMessagesClient {
	mock := &MockAdminService_StreamWorkflowReplicationMessagesClient{ctrl: ctrl}
	mock.recorder = &MockAdminService_StreamWorkflowReplicationMessagesClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockAdminService_StreamWorkflowReplicationMessagesClientMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockAdminService_StreamWorkflowReplicationMessagesClient)(nil).RecvMsg), m)
}

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

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

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

// SendMsg indicates an expected call of SendMsg.
func (mr *MockAdminService_StreamWorkflowReplicationMessagesClientMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockAdminService_StreamWorkflowReplicationMessagesClient)(nil).SendMsg), m)
}

// Trailer mocks base method.
func (m *MockAdminService_StreamWorkflowReplicationMessagesClient) Trailer() metadata.MD {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Trailer")
	ret0, _ := ret[0].(metadata.MD)
	return ret0
}

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

// MockAdminServiceServer is a mock of AdminServiceServer interface.
type MockAdminServiceServer struct {
	ctrl     *gomock.Controller
	recorder *MockAdminServiceServerMockRecorder
	isgomock struct{}
}

// MockAdminServiceServerMockRecorder is the mock recorder for MockAdminServiceServer.
type MockAdminServiceServerMockRecorder struct {
	mock *MockAdminServiceServer
}

// NewMockAdminServiceServer creates a new mock instance.
func NewMockAdminServiceServer(ctrl *gomock.Controller) *MockAdminServiceServer {
	mock := &MockAdminServiceServer{ctrl: ctrl}
	mock.recorder = &MockAdminServiceServerMockRecorder{mock}
	return mock
}

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

// AddOrUpdateRemoteCluster mocks base method.
func (m *MockAdminServiceServer) AddOrUpdateRemoteCluster(arg0 context.Context, arg1 *adminservice.AddOrUpdateRemoteClusterRequest) (*adminservice.AddOrUpdateRemoteClusterResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddOrUpdateRemoteCluster", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.AddOrUpdateRemoteClusterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AddSearchAttributes mocks base method.
func (m *MockAdminServiceServer) AddSearchAttributes(arg0 context.Context, arg1 *adminservice.AddSearchAttributesRequest) (*adminservice.AddSearchAttributesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddSearchAttributes", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.AddSearchAttributesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AddTasks mocks base method.
func (m *MockAdminServiceServer) AddTasks(arg0 context.Context, arg1 *adminservice.AddTasksRequest) (*adminservice.AddTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddTasks", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.AddTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CancelDLQJob mocks base method.
func (m *MockAdminServiceServer) CancelDLQJob(arg0 context.Context, arg1 *adminservice.CancelDLQJobRequest) (*adminservice.CancelDLQJobResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelDLQJob", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.CancelDLQJobResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CloseShard mocks base method.
func (m *MockAdminServiceServer) CloseShard(arg0 context.Context, arg1 *adminservice.CloseShardRequest) (*adminservice.CloseShardResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseShard", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.CloseShardResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeepHealthCheck mocks base method.
func (m *MockAdminServiceServer) DeepHealthCheck(arg0 context.Context, arg1 *adminservice.DeepHealthCheckRequest) (*adminservice.DeepHealthCheckResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeepHealthCheck", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.DeepHealthCheckResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteWorkflowExecution mocks base method.
func (m *MockAdminServiceServer) DeleteWorkflowExecution(arg0 context.Context, arg1 *adminservice.DeleteWorkflowExecutionRequest) (*adminservice.DeleteWorkflowExecutionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteWorkflowExecution", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.DeleteWorkflowExecutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeCluster mocks base method.
func (m *MockAdminServiceServer) DescribeCluster(arg0 context.Context, arg1 *adminservice.DescribeClusterRequest) (*adminservice.DescribeClusterResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCluster", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.DescribeClusterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeDLQJob mocks base method.
func (m *MockAdminServiceServer) DescribeDLQJob(arg0 context.Context, arg1 *adminservice.DescribeDLQJobRequest) (*adminservice.DescribeDLQJobResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeDLQJob", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.DescribeDLQJobResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeHistoryHost mocks base method.
func (m *MockAdminServiceServer) DescribeHistoryHost(arg0 context.Context, arg1 *adminservice.DescribeHistoryHostRequest) (*adminservice.DescribeHistoryHostResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeHistoryHost", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.DescribeHistoryHostResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeMutableState mocks base method.
func (m *MockAdminServiceServer) DescribeMutableState(arg0 context.Context, arg1 *adminservice.DescribeMutableStateRequest) (*adminservice.DescribeMutableStateResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeMutableState", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.DescribeMutableStateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTaskQueuePartition mocks base method.
func (m *MockAdminServiceServer) DescribeTaskQueuePartition(arg0 context.Context, arg1 *adminservice.DescribeTaskQueuePartitionRequest) (*adminservice.DescribeTaskQueuePartitionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTaskQueuePartition", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.DescribeTaskQueuePartitionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ForceUnloadTaskQueuePartition mocks base method.
func (m *MockAdminServiceServer) ForceUnloadTaskQueuePartition(arg0 context.Context, arg1 *adminservice.ForceUnloadTaskQueuePartitionRequest) (*adminservice.ForceUnloadTaskQueuePartitionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForceUnloadTaskQueuePartition", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.ForceUnloadTaskQueuePartitionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GenerateLastHistoryReplicationTasks mocks base method.
func (m *MockAdminServiceServer) GenerateLastHistoryReplicationTasks(arg0 context.Context, arg1 *adminservice.GenerateLastHistoryReplicationTasksRequest) (*adminservice.GenerateLastHistoryReplicationTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenerateLastHistoryReplicationTasks", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.GenerateLastHistoryReplicationTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetDLQMessages mocks base method.
func (m *MockAdminServiceServer) GetDLQMessages(arg0 context.Context, arg1 *adminservice.GetDLQMessagesRequest) (*adminservice.GetDLQMessagesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDLQMessages", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.GetDLQMessagesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetDLQReplicationMessages mocks base method.
func (m *MockAdminServiceServer) GetDLQReplicationMessages(arg0 context.Context, arg1 *adminservice.GetDLQReplicationMessagesRequest) (*adminservice.GetDLQReplicationMessagesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDLQReplicationMessages", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.GetDLQReplicationMessagesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetDLQTasks mocks base method.
func (m *MockAdminServiceServer) GetDLQTasks(arg0 context.Context, arg1 *adminservice.GetDLQTasksRequest) (*adminservice.GetDLQTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDLQTasks", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.GetDLQTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNamespace mocks base method.
func (m *MockAdminServiceServer) GetNamespace(arg0 context.Context, arg1 *adminservice.GetNamespaceRequest) (*adminservice.GetNamespaceResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNamespace", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.GetNamespaceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetNamespaceReplicationMessages mocks base method.
func (m *MockAdminServiceServer) GetNamespaceReplicationMessages(arg0 context.Context, arg1 *adminservice.GetNamespaceReplicationMessagesRequest) (*adminservice.GetNamespaceReplicationMessagesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNamespaceReplicationMessages", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.GetNamespaceReplicationMessagesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetReplicationMessages mocks base method.
func (m *MockAdminServiceServer) GetReplicationMessages(arg0 context.Context, arg1 *adminservice.GetReplicationMessagesRequest) (*adminservice.GetReplicationMessagesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReplicationMessages", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.GetReplicationMessagesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetSearchAttributes mocks base method.
func (m *MockAdminServiceServer) GetSearchAttributes(arg0 context.Context, arg1 *adminservice.GetSearchAttributesRequest) (*adminservice.GetSearchAttributesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSearchAttributes", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.GetSearchAttributesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetShard mocks base method.
func (m *MockAdminServiceServer) GetShard(arg0 context.Context, arg1 *adminservice.GetShardRequest) (*adminservice.GetShardResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetShard", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.GetShardResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTaskQueueTasks mocks base method.
func (m *MockAdminServiceServer) GetTaskQueueTasks(arg0 context.Context, arg1 *adminservice.GetTaskQueueTasksRequest) (*adminservice.GetTaskQueueTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTaskQueueTasks", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.GetTaskQueueTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWorkflowExecutionRawHistory mocks base method.
func (m *MockAdminServiceServer) GetWorkflowExecutionRawHistory(arg0 context.Context, arg1 *adminservice.GetWorkflowExecutionRawHistoryRequest) (*adminservice.GetWorkflowExecutionRawHistoryResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkflowExecutionRawHistory", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.GetWorkflowExecutionRawHistoryResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWorkflowExecutionRawHistoryV2 mocks base method.
func (m *MockAdminServiceServer) GetWorkflowExecutionRawHistoryV2(arg0 context.Context, arg1 *adminservice.GetWorkflowExecutionRawHistoryV2Request) (*adminservice.GetWorkflowExecutionRawHistoryV2Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkflowExecutionRawHistoryV2", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.GetWorkflowExecutionRawHistoryV2Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ImportWorkflowExecution mocks base method.
func (m *MockAdminServiceServer) ImportWorkflowExecution(arg0 context.Context, arg1 *adminservice.ImportWorkflowExecutionRequest) (*adminservice.ImportWorkflowExecutionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImportWorkflowExecution", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.ImportWorkflowExecutionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListClusterMembers mocks base method.
func (m *MockAdminServiceServer) ListClusterMembers(arg0 context.Context, arg1 *adminservice.ListClusterMembersRequest) (*adminservice.ListClusterMembersResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListClusterMembers", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.ListClusterMembersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListClusters mocks base method.
func (m *MockAdminServiceServer) ListClusters(arg0 context.Context, arg1 *adminservice.ListClustersRequest) (*adminservice.ListClustersResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListClusters", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.ListClustersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListHistoryTasks mocks base method.
func (m *MockAdminServiceServer) ListHistoryTasks(arg0 context.Context, arg1 *adminservice.ListHistoryTasksRequest) (*adminservice.ListHistoryTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListHistoryTasks", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.ListHistoryTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListQueues mocks base method.
func (m *MockAdminServiceServer) ListQueues(arg0 context.Context, arg1 *adminservice.ListQueuesRequest) (*adminservice.ListQueuesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListQueues", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.ListQueuesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MergeDLQMessages mocks base method.
func (m *MockAdminServiceServer) MergeDLQMessages(arg0 context.Context, arg1 *adminservice.MergeDLQMessagesRequest) (*adminservice.MergeDLQMessagesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MergeDLQMessages", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.MergeDLQMessagesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MergeDLQTasks mocks base method.
func (m *MockAdminServiceServer) MergeDLQTasks(arg0 context.Context, arg1 *adminservice.MergeDLQTasksRequest) (*adminservice.MergeDLQTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MergeDLQTasks", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.MergeDLQTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PurgeDLQMessages mocks base method.
func (m *MockAdminServiceServer) PurgeDLQMessages(arg0 context.Context, arg1 *adminservice.PurgeDLQMessagesRequest) (*adminservice.PurgeDLQMessagesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PurgeDLQMessages", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.PurgeDLQMessagesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PurgeDLQTasks mocks base method.
func (m *MockAdminServiceServer) PurgeDLQTasks(arg0 context.Context, arg1 *adminservice.PurgeDLQTasksRequest) (*adminservice.PurgeDLQTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PurgeDLQTasks", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.PurgeDLQTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReapplyEvents mocks base method.
func (m *MockAdminServiceServer) ReapplyEvents(arg0 context.Context, arg1 *adminservice.ReapplyEventsRequest) (*adminservice.ReapplyEventsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReapplyEvents", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.ReapplyEventsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RebuildMutableState mocks base method.
func (m *MockAdminServiceServer) RebuildMutableState(arg0 context.Context, arg1 *adminservice.RebuildMutableStateRequest) (*adminservice.RebuildMutableStateResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RebuildMutableState", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.RebuildMutableStateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RefreshWorkflowTasks mocks base method.
func (m *MockAdminServiceServer) RefreshWorkflowTasks(arg0 context.Context, arg1 *adminservice.RefreshWorkflowTasksRequest) (*adminservice.RefreshWorkflowTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RefreshWorkflowTasks", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.RefreshWorkflowTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RemoveRemoteCluster mocks base method.
func (m *MockAdminServiceServer) RemoveRemoteCluster(arg0 context.Context, arg1 *adminservice.RemoveRemoteClusterRequest) (*adminservice.RemoveRemoteClusterResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveRemoteCluster", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.RemoveRemoteClusterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RemoveSearchAttributes mocks base method.
func (m *MockAdminServiceServer) RemoveSearchAttributes(arg0 context.Context, arg1 *adminservice.RemoveSearchAttributesRequest) (*adminservice.RemoveSearchAttributesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveSearchAttributes", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.RemoveSearchAttributesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RemoveTask mocks base method.
func (m *MockAdminServiceServer) RemoveTask(arg0 context.Context, arg1 *adminservice.RemoveTaskRequest) (*adminservice.RemoveTaskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveTask", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.RemoveTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ResendReplicationTasks mocks base method.
func (m *MockAdminServiceServer) ResendReplicationTasks(arg0 context.Context, arg1 *adminservice.ResendReplicationTasksRequest) (*adminservice.ResendReplicationTasksResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResendReplicationTasks", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.ResendReplicationTasksResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// StartAdminBatchOperation mocks base method.
func (m *MockAdminServiceServer) StartAdminBatchOperation(arg0 context.Context, arg1 *adminservice.StartAdminBatchOperationRequest) (*adminservice.StartAdminBatchOperationResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartAdminBatchOperation", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.StartAdminBatchOperationResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// SyncWorkflowState mocks base method.
func (m *MockAdminServiceServer) SyncWorkflowState(arg0 context.Context, arg1 *adminservice.SyncWorkflowStateRequest) (*adminservice.SyncWorkflowStateResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SyncWorkflowState", arg0, arg1)
	ret0, _ := ret[0].(*adminservice.SyncWorkflowStateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// mustEmbedUnimplementedAdminServiceServer mocks base method.
func (m *MockAdminServiceServer) mustEmbedUnimplementedAdminServiceServer() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "mustEmbedUnimplementedAdminServiceServer")
}

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

// MockUnsafeAdminServiceServer is a mock of UnsafeAdminServiceServer interface.
type MockUnsafeAdminServiceServer struct {
	ctrl     *gomock.Controller
	recorder *MockUnsafeAdminServiceServerMockRecorder
	isgomock struct{}
}

// MockUnsafeAdminServiceServerMockRecorder is the mock recorder for MockUnsafeAdminServiceServer.
type MockUnsafeAdminServiceServerMockRecorder struct {
	mock *MockUnsafeAdminServiceServer
}

// NewMockUnsafeAdminServiceServer creates a new mock instance.
func NewMockUnsafeAdminServiceServer(ctrl *gomock.Controller) *MockUnsafeAdminServiceServer {
	mock := &MockUnsafeAdminServiceServer{ctrl: ctrl}
	mock.recorder = &MockUnsafeAdminServiceServerMockRecorder{mock}
	return mock
}

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

// mustEmbedUnimplementedAdminServiceServer mocks base method.
func (m *MockUnsafeAdminServiceServer) mustEmbedUnimplementedAdminServiceServer() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "mustEmbedUnimplementedAdminServiceServer")
}

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

// MockAdminService_StreamWorkflowReplicationMessagesServer is a mock of AdminService_StreamWorkflowReplicationMessagesServer interface.
type MockAdminService_StreamWorkflowReplicationMessagesServer struct {
	ctrl     *gomock.Controller
	recorder *MockAdminService_StreamWorkflowReplicationMessagesServerMockRecorder
	isgomock struct{}
}

// MockAdminService_StreamWorkflowReplicationMessagesServerMockRecorder is the mock recorder for MockAdminService_StreamWorkflowReplicationMessagesServer.
type MockAdminService_StreamWorkflowReplicationMessagesServerMockRecorder struct {
	mock *MockAdminService_StreamWorkflowReplicationMessagesServer
}

// NewMockAdminService_StreamWorkflowReplicationMessagesServer creates a new mock instance.
func NewMockAdminService_StreamWorkflowReplicationMessagesServer(ctrl *gomock.Controller) *MockAdminService_StreamWorkflowReplicationMessagesServer {
	mock := &MockAdminService_StreamWorkflowReplicationMessagesServer{ctrl: ctrl}
	mock.recorder = &MockAdminService_StreamWorkflowReplicationMessagesServerMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

// RecvMsg indicates an expected call of RecvMsg.
func (mr *MockAdminService_StreamWorkflowReplicationMessagesServerMockRecorder) RecvMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecvMsg", reflect.TypeOf((*MockAdminService_StreamWorkflowReplicationMessagesServer)(nil).RecvMsg), m)
}

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

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

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

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

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

// SendMsg indicates an expected call of SendMsg.
func (mr *MockAdminService_StreamWorkflowReplicationMessagesServerMockRecorder) SendMsg(m any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMsg", reflect.TypeOf((*MockAdminService_StreamWorkflowReplicationMessagesServer)(nil).SendMsg), m)
}

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

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

// SetTrailer mocks base method.
func (m *MockAdminService_StreamWorkflowReplicationMessagesServer) SetTrailer(arg0 metadata.MD) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetTrailer", arg0)
}

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