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

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

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

import (
	context "context"
	reflect "reflect"

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

// MockMatchingServiceClient is a mock of MatchingServiceClient interface.
type MockMatchingServiceClient struct {
	ctrl     *gomock.Controller
	recorder *MockMatchingServiceClientMockRecorder
	isgomock struct{}
}

// MockMatchingServiceClientMockRecorder is the mock recorder for MockMatchingServiceClient.
type MockMatchingServiceClientMockRecorder struct {
	mock *MockMatchingServiceClient
}

// NewMockMatchingServiceClient creates a new mock instance.
func NewMockMatchingServiceClient(ctrl *gomock.Controller) *MockMatchingServiceClient {
	mock := &MockMatchingServiceClient{ctrl: ctrl}
	mock.recorder = &MockMatchingServiceClientMockRecorder{mock}
	return mock
}

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

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

// AddActivityTask indicates an expected call of AddActivityTask.
func (mr *MockMatchingServiceClientMockRecorder) AddActivityTask(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, "AddActivityTask", reflect.TypeOf((*MockMatchingServiceClient)(nil).AddActivityTask), varargs...)
}

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

// AddWorkflowTask indicates an expected call of AddWorkflowTask.
func (mr *MockMatchingServiceClientMockRecorder) AddWorkflowTask(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, "AddWorkflowTask", reflect.TypeOf((*MockMatchingServiceClient)(nil).AddWorkflowTask), varargs...)
}

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

// ApplyTaskQueueUserDataReplicationEvent indicates an expected call of ApplyTaskQueueUserDataReplicationEvent.
func (mr *MockMatchingServiceClientMockRecorder) ApplyTaskQueueUserDataReplicationEvent(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, "ApplyTaskQueueUserDataReplicationEvent", reflect.TypeOf((*MockMatchingServiceClient)(nil).ApplyTaskQueueUserDataReplicationEvent), varargs...)
}

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

// CancelOutstandingPoll indicates an expected call of CancelOutstandingPoll.
func (mr *MockMatchingServiceClientMockRecorder) CancelOutstandingPoll(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, "CancelOutstandingPoll", reflect.TypeOf((*MockMatchingServiceClient)(nil).CancelOutstandingPoll), varargs...)
}

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

// CheckTaskQueueUserDataPropagation indicates an expected call of CheckTaskQueueUserDataPropagation.
func (mr *MockMatchingServiceClientMockRecorder) CheckTaskQueueUserDataPropagation(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, "CheckTaskQueueUserDataPropagation", reflect.TypeOf((*MockMatchingServiceClient)(nil).CheckTaskQueueUserDataPropagation), varargs...)
}

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

// CheckTaskQueueVersionMembership indicates an expected call of CheckTaskQueueVersionMembership.
func (mr *MockMatchingServiceClientMockRecorder) CheckTaskQueueVersionMembership(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, "CheckTaskQueueVersionMembership", reflect.TypeOf((*MockMatchingServiceClient)(nil).CheckTaskQueueVersionMembership), varargs...)
}

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

// CreateNexusEndpoint indicates an expected call of CreateNexusEndpoint.
func (mr *MockMatchingServiceClientMockRecorder) CreateNexusEndpoint(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, "CreateNexusEndpoint", reflect.TypeOf((*MockMatchingServiceClient)(nil).CreateNexusEndpoint), varargs...)
}

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

// DeleteNexusEndpoint indicates an expected call of DeleteNexusEndpoint.
func (mr *MockMatchingServiceClientMockRecorder) DeleteNexusEndpoint(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, "DeleteNexusEndpoint", reflect.TypeOf((*MockMatchingServiceClient)(nil).DeleteNexusEndpoint), varargs...)
}

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

// DescribeTaskQueue indicates an expected call of DescribeTaskQueue.
func (mr *MockMatchingServiceClientMockRecorder) DescribeTaskQueue(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, "DescribeTaskQueue", reflect.TypeOf((*MockMatchingServiceClient)(nil).DescribeTaskQueue), varargs...)
}

// DescribeTaskQueuePartition mocks base method.
func (m *MockMatchingServiceClient) DescribeTaskQueuePartition(ctx context.Context, in *matchingservice.DescribeTaskQueuePartitionRequest, opts ...grpc.CallOption) (*matchingservice.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].(*matchingservice.DescribeTaskQueuePartitionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DescribeTaskQueuePartition indicates an expected call of DescribeTaskQueuePartition.
func (mr *MockMatchingServiceClientMockRecorder) 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((*MockMatchingServiceClient)(nil).DescribeTaskQueuePartition), varargs...)
}

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

// DescribeVersionedTaskQueues indicates an expected call of DescribeVersionedTaskQueues.
func (mr *MockMatchingServiceClientMockRecorder) DescribeVersionedTaskQueues(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, "DescribeVersionedTaskQueues", reflect.TypeOf((*MockMatchingServiceClient)(nil).DescribeVersionedTaskQueues), varargs...)
}

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

// DescribeWorker indicates an expected call of DescribeWorker.
func (mr *MockMatchingServiceClientMockRecorder) DescribeWorker(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, "DescribeWorker", reflect.TypeOf((*MockMatchingServiceClient)(nil).DescribeWorker), varargs...)
}

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

// DispatchNexusTask indicates an expected call of DispatchNexusTask.
func (mr *MockMatchingServiceClientMockRecorder) DispatchNexusTask(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, "DispatchNexusTask", reflect.TypeOf((*MockMatchingServiceClient)(nil).DispatchNexusTask), varargs...)
}

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

// ForceLoadTaskQueuePartition indicates an expected call of ForceLoadTaskQueuePartition.
func (mr *MockMatchingServiceClientMockRecorder) ForceLoadTaskQueuePartition(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, "ForceLoadTaskQueuePartition", reflect.TypeOf((*MockMatchingServiceClient)(nil).ForceLoadTaskQueuePartition), varargs...)
}

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

// ForceUnloadTaskQueue indicates an expected call of ForceUnloadTaskQueue.
func (mr *MockMatchingServiceClientMockRecorder) ForceUnloadTaskQueue(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, "ForceUnloadTaskQueue", reflect.TypeOf((*MockMatchingServiceClient)(nil).ForceUnloadTaskQueue), varargs...)
}

// ForceUnloadTaskQueuePartition mocks base method.
func (m *MockMatchingServiceClient) ForceUnloadTaskQueuePartition(ctx context.Context, in *matchingservice.ForceUnloadTaskQueuePartitionRequest, opts ...grpc.CallOption) (*matchingservice.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].(*matchingservice.ForceUnloadTaskQueuePartitionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ForceUnloadTaskQueuePartition indicates an expected call of ForceUnloadTaskQueuePartition.
func (mr *MockMatchingServiceClientMockRecorder) 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((*MockMatchingServiceClient)(nil).ForceUnloadTaskQueuePartition), varargs...)
}

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

// GetBuildIdTaskQueueMapping indicates an expected call of GetBuildIdTaskQueueMapping.
func (mr *MockMatchingServiceClientMockRecorder) GetBuildIdTaskQueueMapping(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, "GetBuildIdTaskQueueMapping", reflect.TypeOf((*MockMatchingServiceClient)(nil).GetBuildIdTaskQueueMapping), varargs...)
}

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

// GetTaskQueueUserData indicates an expected call of GetTaskQueueUserData.
func (mr *MockMatchingServiceClientMockRecorder) GetTaskQueueUserData(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, "GetTaskQueueUserData", reflect.TypeOf((*MockMatchingServiceClient)(nil).GetTaskQueueUserData), varargs...)
}

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

// GetWorkerBuildIdCompatibility indicates an expected call of GetWorkerBuildIdCompatibility.
func (mr *MockMatchingServiceClientMockRecorder) GetWorkerBuildIdCompatibility(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, "GetWorkerBuildIdCompatibility", reflect.TypeOf((*MockMatchingServiceClient)(nil).GetWorkerBuildIdCompatibility), varargs...)
}

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

// GetWorkerVersioningRules indicates an expected call of GetWorkerVersioningRules.
func (mr *MockMatchingServiceClientMockRecorder) GetWorkerVersioningRules(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, "GetWorkerVersioningRules", reflect.TypeOf((*MockMatchingServiceClient)(nil).GetWorkerVersioningRules), varargs...)
}

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

// ListNexusEndpoints indicates an expected call of ListNexusEndpoints.
func (mr *MockMatchingServiceClientMockRecorder) ListNexusEndpoints(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, "ListNexusEndpoints", reflect.TypeOf((*MockMatchingServiceClient)(nil).ListNexusEndpoints), varargs...)
}

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

// ListTaskQueuePartitions indicates an expected call of ListTaskQueuePartitions.
func (mr *MockMatchingServiceClientMockRecorder) ListTaskQueuePartitions(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, "ListTaskQueuePartitions", reflect.TypeOf((*MockMatchingServiceClient)(nil).ListTaskQueuePartitions), varargs...)
}

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

// ListWorkers indicates an expected call of ListWorkers.
func (mr *MockMatchingServiceClientMockRecorder) ListWorkers(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, "ListWorkers", reflect.TypeOf((*MockMatchingServiceClient)(nil).ListWorkers), varargs...)
}

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

// PollActivityTaskQueue indicates an expected call of PollActivityTaskQueue.
func (mr *MockMatchingServiceClientMockRecorder) PollActivityTaskQueue(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, "PollActivityTaskQueue", reflect.TypeOf((*MockMatchingServiceClient)(nil).PollActivityTaskQueue), varargs...)
}

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

// PollNexusTaskQueue indicates an expected call of PollNexusTaskQueue.
func (mr *MockMatchingServiceClientMockRecorder) PollNexusTaskQueue(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, "PollNexusTaskQueue", reflect.TypeOf((*MockMatchingServiceClient)(nil).PollNexusTaskQueue), varargs...)
}

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

// PollWorkflowTaskQueue indicates an expected call of PollWorkflowTaskQueue.
func (mr *MockMatchingServiceClientMockRecorder) PollWorkflowTaskQueue(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, "PollWorkflowTaskQueue", reflect.TypeOf((*MockMatchingServiceClient)(nil).PollWorkflowTaskQueue), varargs...)
}

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

// QueryWorkflow indicates an expected call of QueryWorkflow.
func (mr *MockMatchingServiceClientMockRecorder) QueryWorkflow(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, "QueryWorkflow", reflect.TypeOf((*MockMatchingServiceClient)(nil).QueryWorkflow), varargs...)
}

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

// RecordWorkerHeartbeat indicates an expected call of RecordWorkerHeartbeat.
func (mr *MockMatchingServiceClientMockRecorder) RecordWorkerHeartbeat(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, "RecordWorkerHeartbeat", reflect.TypeOf((*MockMatchingServiceClient)(nil).RecordWorkerHeartbeat), varargs...)
}

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

// ReplicateTaskQueueUserData indicates an expected call of ReplicateTaskQueueUserData.
func (mr *MockMatchingServiceClientMockRecorder) ReplicateTaskQueueUserData(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, "ReplicateTaskQueueUserData", reflect.TypeOf((*MockMatchingServiceClient)(nil).ReplicateTaskQueueUserData), varargs...)
}

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

// RespondNexusTaskCompleted indicates an expected call of RespondNexusTaskCompleted.
func (mr *MockMatchingServiceClientMockRecorder) RespondNexusTaskCompleted(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, "RespondNexusTaskCompleted", reflect.TypeOf((*MockMatchingServiceClient)(nil).RespondNexusTaskCompleted), varargs...)
}

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

// RespondNexusTaskFailed indicates an expected call of RespondNexusTaskFailed.
func (mr *MockMatchingServiceClientMockRecorder) RespondNexusTaskFailed(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, "RespondNexusTaskFailed", reflect.TypeOf((*MockMatchingServiceClient)(nil).RespondNexusTaskFailed), varargs...)
}

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

// RespondQueryTaskCompleted indicates an expected call of RespondQueryTaskCompleted.
func (mr *MockMatchingServiceClientMockRecorder) RespondQueryTaskCompleted(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, "RespondQueryTaskCompleted", reflect.TypeOf((*MockMatchingServiceClient)(nil).RespondQueryTaskCompleted), varargs...)
}

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

// SyncDeploymentUserData indicates an expected call of SyncDeploymentUserData.
func (mr *MockMatchingServiceClientMockRecorder) SyncDeploymentUserData(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, "SyncDeploymentUserData", reflect.TypeOf((*MockMatchingServiceClient)(nil).SyncDeploymentUserData), varargs...)
}

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

// UpdateFairnessState indicates an expected call of UpdateFairnessState.
func (mr *MockMatchingServiceClientMockRecorder) UpdateFairnessState(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, "UpdateFairnessState", reflect.TypeOf((*MockMatchingServiceClient)(nil).UpdateFairnessState), varargs...)
}

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

// UpdateNexusEndpoint indicates an expected call of UpdateNexusEndpoint.
func (mr *MockMatchingServiceClientMockRecorder) UpdateNexusEndpoint(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, "UpdateNexusEndpoint", reflect.TypeOf((*MockMatchingServiceClient)(nil).UpdateNexusEndpoint), varargs...)
}

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

// UpdateTaskQueueConfig indicates an expected call of UpdateTaskQueueConfig.
func (mr *MockMatchingServiceClientMockRecorder) UpdateTaskQueueConfig(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, "UpdateTaskQueueConfig", reflect.TypeOf((*MockMatchingServiceClient)(nil).UpdateTaskQueueConfig), varargs...)
}

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

// UpdateTaskQueueUserData indicates an expected call of UpdateTaskQueueUserData.
func (mr *MockMatchingServiceClientMockRecorder) UpdateTaskQueueUserData(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, "UpdateTaskQueueUserData", reflect.TypeOf((*MockMatchingServiceClient)(nil).UpdateTaskQueueUserData), varargs...)
}

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

// UpdateWorkerBuildIdCompatibility indicates an expected call of UpdateWorkerBuildIdCompatibility.
func (mr *MockMatchingServiceClientMockRecorder) UpdateWorkerBuildIdCompatibility(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, "UpdateWorkerBuildIdCompatibility", reflect.TypeOf((*MockMatchingServiceClient)(nil).UpdateWorkerBuildIdCompatibility), varargs...)
}

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

// UpdateWorkerVersioningRules indicates an expected call of UpdateWorkerVersioningRules.
func (mr *MockMatchingServiceClientMockRecorder) UpdateWorkerVersioningRules(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, "UpdateWorkerVersioningRules", reflect.TypeOf((*MockMatchingServiceClient)(nil).UpdateWorkerVersioningRules), varargs...)
}

// MockMatchingServiceServer is a mock of MatchingServiceServer interface.
type MockMatchingServiceServer struct {
	ctrl     *gomock.Controller
	recorder *MockMatchingServiceServerMockRecorder
	isgomock struct{}
}

// MockMatchingServiceServerMockRecorder is the mock recorder for MockMatchingServiceServer.
type MockMatchingServiceServerMockRecorder struct {
	mock *MockMatchingServiceServer
}

// NewMockMatchingServiceServer creates a new mock instance.
func NewMockMatchingServiceServer(ctrl *gomock.Controller) *MockMatchingServiceServer {
	mock := &MockMatchingServiceServer{ctrl: ctrl}
	mock.recorder = &MockMatchingServiceServerMockRecorder{mock}
	return mock
}

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

// AddActivityTask mocks base method.
func (m *MockMatchingServiceServer) AddActivityTask(arg0 context.Context, arg1 *matchingservice.AddActivityTaskRequest) (*matchingservice.AddActivityTaskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddActivityTask", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.AddActivityTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AddWorkflowTask mocks base method.
func (m *MockMatchingServiceServer) AddWorkflowTask(arg0 context.Context, arg1 *matchingservice.AddWorkflowTaskRequest) (*matchingservice.AddWorkflowTaskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddWorkflowTask", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.AddWorkflowTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ApplyTaskQueueUserDataReplicationEvent mocks base method.
func (m *MockMatchingServiceServer) ApplyTaskQueueUserDataReplicationEvent(arg0 context.Context, arg1 *matchingservice.ApplyTaskQueueUserDataReplicationEventRequest) (*matchingservice.ApplyTaskQueueUserDataReplicationEventResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyTaskQueueUserDataReplicationEvent", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.ApplyTaskQueueUserDataReplicationEventResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CancelOutstandingPoll mocks base method.
func (m *MockMatchingServiceServer) CancelOutstandingPoll(arg0 context.Context, arg1 *matchingservice.CancelOutstandingPollRequest) (*matchingservice.CancelOutstandingPollResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelOutstandingPoll", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.CancelOutstandingPollResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CheckTaskQueueUserDataPropagation mocks base method.
func (m *MockMatchingServiceServer) CheckTaskQueueUserDataPropagation(arg0 context.Context, arg1 *matchingservice.CheckTaskQueueUserDataPropagationRequest) (*matchingservice.CheckTaskQueueUserDataPropagationResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckTaskQueueUserDataPropagation", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.CheckTaskQueueUserDataPropagationResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CheckTaskQueueVersionMembership mocks base method.
func (m *MockMatchingServiceServer) CheckTaskQueueVersionMembership(arg0 context.Context, arg1 *matchingservice.CheckTaskQueueVersionMembershipRequest) (*matchingservice.CheckTaskQueueVersionMembershipResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckTaskQueueVersionMembership", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.CheckTaskQueueVersionMembershipResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateNexusEndpoint mocks base method.
func (m *MockMatchingServiceServer) CreateNexusEndpoint(arg0 context.Context, arg1 *matchingservice.CreateNexusEndpointRequest) (*matchingservice.CreateNexusEndpointResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNexusEndpoint", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.CreateNexusEndpointResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteNexusEndpoint mocks base method.
func (m *MockMatchingServiceServer) DeleteNexusEndpoint(arg0 context.Context, arg1 *matchingservice.DeleteNexusEndpointRequest) (*matchingservice.DeleteNexusEndpointResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNexusEndpoint", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.DeleteNexusEndpointResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeTaskQueue mocks base method.
func (m *MockMatchingServiceServer) DescribeTaskQueue(arg0 context.Context, arg1 *matchingservice.DescribeTaskQueueRequest) (*matchingservice.DescribeTaskQueueResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeTaskQueue", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.DescribeTaskQueueResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// DescribeVersionedTaskQueues mocks base method.
func (m *MockMatchingServiceServer) DescribeVersionedTaskQueues(arg0 context.Context, arg1 *matchingservice.DescribeVersionedTaskQueuesRequest) (*matchingservice.DescribeVersionedTaskQueuesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeVersionedTaskQueues", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.DescribeVersionedTaskQueuesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeWorker mocks base method.
func (m *MockMatchingServiceServer) DescribeWorker(arg0 context.Context, arg1 *matchingservice.DescribeWorkerRequest) (*matchingservice.DescribeWorkerResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeWorker", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.DescribeWorkerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DispatchNexusTask mocks base method.
func (m *MockMatchingServiceServer) DispatchNexusTask(arg0 context.Context, arg1 *matchingservice.DispatchNexusTaskRequest) (*matchingservice.DispatchNexusTaskResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DispatchNexusTask", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.DispatchNexusTaskResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ForceLoadTaskQueuePartition mocks base method.
func (m *MockMatchingServiceServer) ForceLoadTaskQueuePartition(arg0 context.Context, arg1 *matchingservice.ForceLoadTaskQueuePartitionRequest) (*matchingservice.ForceLoadTaskQueuePartitionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForceLoadTaskQueuePartition", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.ForceLoadTaskQueuePartitionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ForceUnloadTaskQueue mocks base method.
func (m *MockMatchingServiceServer) ForceUnloadTaskQueue(arg0 context.Context, arg1 *matchingservice.ForceUnloadTaskQueueRequest) (*matchingservice.ForceUnloadTaskQueueResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForceUnloadTaskQueue", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.ForceUnloadTaskQueueResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetBuildIdTaskQueueMapping mocks base method.
func (m *MockMatchingServiceServer) GetBuildIdTaskQueueMapping(arg0 context.Context, arg1 *matchingservice.GetBuildIdTaskQueueMappingRequest) (*matchingservice.GetBuildIdTaskQueueMappingResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBuildIdTaskQueueMapping", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.GetBuildIdTaskQueueMappingResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetTaskQueueUserData mocks base method.
func (m *MockMatchingServiceServer) GetTaskQueueUserData(arg0 context.Context, arg1 *matchingservice.GetTaskQueueUserDataRequest) (*matchingservice.GetTaskQueueUserDataResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTaskQueueUserData", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.GetTaskQueueUserDataResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWorkerBuildIdCompatibility mocks base method.
func (m *MockMatchingServiceServer) GetWorkerBuildIdCompatibility(arg0 context.Context, arg1 *matchingservice.GetWorkerBuildIdCompatibilityRequest) (*matchingservice.GetWorkerBuildIdCompatibilityResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkerBuildIdCompatibility", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.GetWorkerBuildIdCompatibilityResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetWorkerVersioningRules mocks base method.
func (m *MockMatchingServiceServer) GetWorkerVersioningRules(arg0 context.Context, arg1 *matchingservice.GetWorkerVersioningRulesRequest) (*matchingservice.GetWorkerVersioningRulesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetWorkerVersioningRules", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.GetWorkerVersioningRulesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListNexusEndpoints mocks base method.
func (m *MockMatchingServiceServer) ListNexusEndpoints(arg0 context.Context, arg1 *matchingservice.ListNexusEndpointsRequest) (*matchingservice.ListNexusEndpointsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNexusEndpoints", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.ListNexusEndpointsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTaskQueuePartitions mocks base method.
func (m *MockMatchingServiceServer) ListTaskQueuePartitions(arg0 context.Context, arg1 *matchingservice.ListTaskQueuePartitionsRequest) (*matchingservice.ListTaskQueuePartitionsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTaskQueuePartitions", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.ListTaskQueuePartitionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListWorkers mocks base method.
func (m *MockMatchingServiceServer) ListWorkers(arg0 context.Context, arg1 *matchingservice.ListWorkersRequest) (*matchingservice.ListWorkersResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListWorkers", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.ListWorkersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PollActivityTaskQueue mocks base method.
func (m *MockMatchingServiceServer) PollActivityTaskQueue(arg0 context.Context, arg1 *matchingservice.PollActivityTaskQueueRequest) (*matchingservice.PollActivityTaskQueueResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PollActivityTaskQueue", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.PollActivityTaskQueueResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PollNexusTaskQueue mocks base method.
func (m *MockMatchingServiceServer) PollNexusTaskQueue(arg0 context.Context, arg1 *matchingservice.PollNexusTaskQueueRequest) (*matchingservice.PollNexusTaskQueueResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PollNexusTaskQueue", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.PollNexusTaskQueueResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PollWorkflowTaskQueue mocks base method.
func (m *MockMatchingServiceServer) PollWorkflowTaskQueue(arg0 context.Context, arg1 *matchingservice.PollWorkflowTaskQueueRequest) (*matchingservice.PollWorkflowTaskQueueResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PollWorkflowTaskQueue", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.PollWorkflowTaskQueueResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// QueryWorkflow mocks base method.
func (m *MockMatchingServiceServer) QueryWorkflow(arg0 context.Context, arg1 *matchingservice.QueryWorkflowRequest) (*matchingservice.QueryWorkflowResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryWorkflow", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.QueryWorkflowResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RecordWorkerHeartbeat mocks base method.
func (m *MockMatchingServiceServer) RecordWorkerHeartbeat(arg0 context.Context, arg1 *matchingservice.RecordWorkerHeartbeatRequest) (*matchingservice.RecordWorkerHeartbeatResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RecordWorkerHeartbeat", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.RecordWorkerHeartbeatResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReplicateTaskQueueUserData mocks base method.
func (m *MockMatchingServiceServer) ReplicateTaskQueueUserData(arg0 context.Context, arg1 *matchingservice.ReplicateTaskQueueUserDataRequest) (*matchingservice.ReplicateTaskQueueUserDataResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplicateTaskQueueUserData", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.ReplicateTaskQueueUserDataResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RespondNexusTaskCompleted mocks base method.
func (m *MockMatchingServiceServer) RespondNexusTaskCompleted(arg0 context.Context, arg1 *matchingservice.RespondNexusTaskCompletedRequest) (*matchingservice.RespondNexusTaskCompletedResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RespondNexusTaskCompleted", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.RespondNexusTaskCompletedResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RespondNexusTaskFailed mocks base method.
func (m *MockMatchingServiceServer) RespondNexusTaskFailed(arg0 context.Context, arg1 *matchingservice.RespondNexusTaskFailedRequest) (*matchingservice.RespondNexusTaskFailedResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RespondNexusTaskFailed", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.RespondNexusTaskFailedResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RespondQueryTaskCompleted mocks base method.
func (m *MockMatchingServiceServer) RespondQueryTaskCompleted(arg0 context.Context, arg1 *matchingservice.RespondQueryTaskCompletedRequest) (*matchingservice.RespondQueryTaskCompletedResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RespondQueryTaskCompleted", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.RespondQueryTaskCompletedResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SyncDeploymentUserData mocks base method.
func (m *MockMatchingServiceServer) SyncDeploymentUserData(arg0 context.Context, arg1 *matchingservice.SyncDeploymentUserDataRequest) (*matchingservice.SyncDeploymentUserDataResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SyncDeploymentUserData", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.SyncDeploymentUserDataResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateFairnessState mocks base method.
func (m *MockMatchingServiceServer) UpdateFairnessState(arg0 context.Context, arg1 *matchingservice.UpdateFairnessStateRequest) (*matchingservice.UpdateFairnessStateResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateFairnessState", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.UpdateFairnessStateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateNexusEndpoint mocks base method.
func (m *MockMatchingServiceServer) UpdateNexusEndpoint(arg0 context.Context, arg1 *matchingservice.UpdateNexusEndpointRequest) (*matchingservice.UpdateNexusEndpointResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNexusEndpoint", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.UpdateNexusEndpointResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateTaskQueueConfig mocks base method.
func (m *MockMatchingServiceServer) UpdateTaskQueueConfig(arg0 context.Context, arg1 *matchingservice.UpdateTaskQueueConfigRequest) (*matchingservice.UpdateTaskQueueConfigResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTaskQueueConfig", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.UpdateTaskQueueConfigResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateTaskQueueUserData mocks base method.
func (m *MockMatchingServiceServer) UpdateTaskQueueUserData(arg0 context.Context, arg1 *matchingservice.UpdateTaskQueueUserDataRequest) (*matchingservice.UpdateTaskQueueUserDataResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateTaskQueueUserData", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.UpdateTaskQueueUserDataResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateWorkerBuildIdCompatibility mocks base method.
func (m *MockMatchingServiceServer) UpdateWorkerBuildIdCompatibility(arg0 context.Context, arg1 *matchingservice.UpdateWorkerBuildIdCompatibilityRequest) (*matchingservice.UpdateWorkerBuildIdCompatibilityResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkerBuildIdCompatibility", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.UpdateWorkerBuildIdCompatibilityResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateWorkerVersioningRules mocks base method.
func (m *MockMatchingServiceServer) UpdateWorkerVersioningRules(arg0 context.Context, arg1 *matchingservice.UpdateWorkerVersioningRulesRequest) (*matchingservice.UpdateWorkerVersioningRulesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWorkerVersioningRules", arg0, arg1)
	ret0, _ := ret[0].(*matchingservice.UpdateWorkerVersioningRulesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// MockUnsafeMatchingServiceServer is a mock of UnsafeMatchingServiceServer interface.
type MockUnsafeMatchingServiceServer struct {
	ctrl     *gomock.Controller
	recorder *MockUnsafeMatchingServiceServerMockRecorder
	isgomock struct{}
}

// MockUnsafeMatchingServiceServerMockRecorder is the mock recorder for MockUnsafeMatchingServiceServer.
type MockUnsafeMatchingServiceServerMockRecorder struct {
	mock *MockUnsafeMatchingServiceServer
}

// NewMockUnsafeMatchingServiceServer creates a new mock instance.
func NewMockUnsafeMatchingServiceServer(ctrl *gomock.Controller) *MockUnsafeMatchingServiceServer {
	mock := &MockUnsafeMatchingServiceServer{ctrl: ctrl}
	mock.recorder = &MockUnsafeMatchingServiceServerMockRecorder{mock}
	return mock
}

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

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

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