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

// The MIT License
//
// Copyright (c) 2020 Temporal Technologies Inc.  All rights reserved.
//
// Copyright (c) 2020 Uber Technologies, Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

// Code generated by MockGen. DO NOT EDIT.
// Source: api/matchingservice/v1/service_grpc.pb.go
//
// Generated by this command:
//
//	mockgen -copyright_file LICENSE -package matchingservicemock -source api/matchingservice/v1/service_grpc.pb.go -destination api.new/temporal/server/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
}

// 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...)
}

// 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...)
}

// 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...)
}

// 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...)
}

// 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...)
}

// 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...)
}

// 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
}

// 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)
}

// 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)
}

// 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)
}

// 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)
}

// 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)
}

// 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)
}

// 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
}

// 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))
}