tasks/common/testing/mockapi/workflowservicemock/v1/service_grpc.pb.mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: go.temporal.io/api/workflowservice/v1 (interfaces: WorkflowServiceClient)
//
// Generated by this command:
//
//	mockgen -package workflowservicemock -destination workflowservicemock/v1/service_grpc.pb.mock.go go.temporal.io/api/workflowservice/v1 WorkflowServiceClient
//

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

import (
	context "context"
	reflect "reflect"

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

// MockWorkflowServiceClient is a mock of WorkflowServiceClient interface.
type MockWorkflowServiceClient struct {
	ctrl     *gomock.Controller
	recorder *MockWorkflowServiceClientMockRecorder
	isgomock struct{}
}

// MockWorkflowServiceClientMockRecorder is the mock recorder for MockWorkflowServiceClient.
type MockWorkflowServiceClientMockRecorder struct {
	mock *MockWorkflowServiceClient
}

// NewMockWorkflowServiceClient creates a new mock instance.
func NewMockWorkflowServiceClient(ctrl *gomock.Controller) *MockWorkflowServiceClient {
	mock := &MockWorkflowServiceClient{ctrl: ctrl}
	mock.recorder = &MockWorkflowServiceClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// DescribeTaskQueue mocks base method.
func (m *MockWorkflowServiceClient) DescribeTaskQueue(ctx context.Context, in *workflowservice.DescribeTaskQueueRequest, opts ...grpc.CallOption) (*workflowservice.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].(*workflowservice.DescribeTaskQueueResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeWorker mocks base method.
func (m *MockWorkflowServiceClient) DescribeWorker(ctx context.Context, in *workflowservice.DescribeWorkerRequest, opts ...grpc.CallOption) (*workflowservice.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].(*workflowservice.DescribeWorkerResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// GetWorkerBuildIdCompatibility mocks base method.
func (m *MockWorkflowServiceClient) GetWorkerBuildIdCompatibility(ctx context.Context, in *workflowservice.GetWorkerBuildIdCompatibilityRequest, opts ...grpc.CallOption) (*workflowservice.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].(*workflowservice.GetWorkerBuildIdCompatibilityResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetWorkerVersioningRules mocks base method.
func (m *MockWorkflowServiceClient) GetWorkerVersioningRules(ctx context.Context, in *workflowservice.GetWorkerVersioningRulesRequest, opts ...grpc.CallOption) (*workflowservice.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].(*workflowservice.GetWorkerVersioningRulesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// ListTaskQueuePartitions mocks base method.
func (m *MockWorkflowServiceClient) ListTaskQueuePartitions(ctx context.Context, in *workflowservice.ListTaskQueuePartitionsRequest, opts ...grpc.CallOption) (*workflowservice.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].(*workflowservice.ListTaskQueuePartitionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// ListWorkers mocks base method.
func (m *MockWorkflowServiceClient) ListWorkers(ctx context.Context, in *workflowservice.ListWorkersRequest, opts ...grpc.CallOption) (*workflowservice.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].(*workflowservice.ListWorkersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// PollActivityTaskQueue mocks base method.
func (m *MockWorkflowServiceClient) PollActivityTaskQueue(ctx context.Context, in *workflowservice.PollActivityTaskQueueRequest, opts ...grpc.CallOption) (*workflowservice.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].(*workflowservice.PollActivityTaskQueueResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// PollNexusTaskQueue mocks base method.
func (m *MockWorkflowServiceClient) PollNexusTaskQueue(ctx context.Context, in *workflowservice.PollNexusTaskQueueRequest, opts ...grpc.CallOption) (*workflowservice.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].(*workflowservice.PollNexusTaskQueueResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// PollWorkflowTaskQueue mocks base method.
func (m *MockWorkflowServiceClient) PollWorkflowTaskQueue(ctx context.Context, in *workflowservice.PollWorkflowTaskQueueRequest, opts ...grpc.CallOption) (*workflowservice.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].(*workflowservice.PollWorkflowTaskQueueResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// QueryWorkflow mocks base method.
func (m *MockWorkflowServiceClient) QueryWorkflow(ctx context.Context, in *workflowservice.QueryWorkflowRequest, opts ...grpc.CallOption) (*workflowservice.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].(*workflowservice.QueryWorkflowResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// RecordWorkerHeartbeat mocks base method.
func (m *MockWorkflowServiceClient) RecordWorkerHeartbeat(ctx context.Context, in *workflowservice.RecordWorkerHeartbeatRequest, opts ...grpc.CallOption) (*workflowservice.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].(*workflowservice.RecordWorkerHeartbeatResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// RespondNexusTaskCompleted mocks base method.
func (m *MockWorkflowServiceClient) RespondNexusTaskCompleted(ctx context.Context, in *workflowservice.RespondNexusTaskCompletedRequest, opts ...grpc.CallOption) (*workflowservice.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].(*workflowservice.RespondNexusTaskCompletedResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RespondNexusTaskFailed mocks base method.
func (m *MockWorkflowServiceClient) RespondNexusTaskFailed(ctx context.Context, in *workflowservice.RespondNexusTaskFailedRequest, opts ...grpc.CallOption) (*workflowservice.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].(*workflowservice.RespondNexusTaskFailedResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RespondQueryTaskCompleted mocks base method.
func (m *MockWorkflowServiceClient) RespondQueryTaskCompleted(ctx context.Context, in *workflowservice.RespondQueryTaskCompletedRequest, opts ...grpc.CallOption) (*workflowservice.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].(*workflowservice.RespondQueryTaskCompletedResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// UpdateTaskQueueConfig mocks base method.
func (m *MockWorkflowServiceClient) UpdateTaskQueueConfig(ctx context.Context, in *workflowservice.UpdateTaskQueueConfigRequest, opts ...grpc.CallOption) (*workflowservice.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].(*workflowservice.UpdateTaskQueueConfigResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateWorkerBuildIdCompatibility mocks base method.
func (m *MockWorkflowServiceClient) UpdateWorkerBuildIdCompatibility(ctx context.Context, in *workflowservice.UpdateWorkerBuildIdCompatibilityRequest, opts ...grpc.CallOption) (*workflowservice.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].(*workflowservice.UpdateWorkerBuildIdCompatibilityResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

// UpdateWorkerVersioningRules mocks base method.
func (m *MockWorkflowServiceClient) UpdateWorkerVersioningRules(ctx context.Context, in *workflowservice.UpdateWorkerVersioningRulesRequest, opts ...grpc.CallOption) (*workflowservice.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].(*workflowservice.UpdateWorkerVersioningRulesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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