// Code generated by mockery v1.0.1. DO NOT EDIT.

package mocks

import (
	context "context"

	admin "github.com/flyteorg/flyte/flyteidl/gen/pb-go/flyteidl/admin"

	mock "github.com/stretchr/testify/mock"
)

// AdminServiceServer is an autogenerated mock type for the AdminServiceServer type
type AdminServiceServer struct {
	mock.Mock
}

type AdminServiceServer_CreateExecution struct {
	*mock.Call
}

func (_m AdminServiceServer_CreateExecution) Return(_a0 *admin.ExecutionCreateResponse, _a1 error) *AdminServiceServer_CreateExecution {
	return &AdminServiceServer_CreateExecution{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnCreateExecution(_a0 context.Context, _a1 *admin.ExecutionCreateRequest) *AdminServiceServer_CreateExecution {
	c_call := _m.On("CreateExecution", _a0, _a1)
	return &AdminServiceServer_CreateExecution{Call: c_call}
}

func (_m *AdminServiceServer) OnCreateExecutionMatch(matchers ...interface{}) *AdminServiceServer_CreateExecution {
	c_call := _m.On("CreateExecution", matchers...)
	return &AdminServiceServer_CreateExecution{Call: c_call}
}

// CreateExecution provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) CreateExecution(_a0 context.Context, _a1 *admin.ExecutionCreateRequest) (*admin.ExecutionCreateResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.ExecutionCreateResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ExecutionCreateRequest) *admin.ExecutionCreateResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.ExecutionCreateResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.ExecutionCreateRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_CreateLaunchPlan struct {
	*mock.Call
}

func (_m AdminServiceServer_CreateLaunchPlan) Return(_a0 *admin.LaunchPlanCreateResponse, _a1 error) *AdminServiceServer_CreateLaunchPlan {
	return &AdminServiceServer_CreateLaunchPlan{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnCreateLaunchPlan(_a0 context.Context, _a1 *admin.LaunchPlanCreateRequest) *AdminServiceServer_CreateLaunchPlan {
	c_call := _m.On("CreateLaunchPlan", _a0, _a1)
	return &AdminServiceServer_CreateLaunchPlan{Call: c_call}
}

func (_m *AdminServiceServer) OnCreateLaunchPlanMatch(matchers ...interface{}) *AdminServiceServer_CreateLaunchPlan {
	c_call := _m.On("CreateLaunchPlan", matchers...)
	return &AdminServiceServer_CreateLaunchPlan{Call: c_call}
}

// CreateLaunchPlan provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) CreateLaunchPlan(_a0 context.Context, _a1 *admin.LaunchPlanCreateRequest) (*admin.LaunchPlanCreateResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.LaunchPlanCreateResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.LaunchPlanCreateRequest) *admin.LaunchPlanCreateResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.LaunchPlanCreateResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.LaunchPlanCreateRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_CreateNodeEvent struct {
	*mock.Call
}

func (_m AdminServiceServer_CreateNodeEvent) Return(_a0 *admin.NodeExecutionEventResponse, _a1 error) *AdminServiceServer_CreateNodeEvent {
	return &AdminServiceServer_CreateNodeEvent{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnCreateNodeEvent(_a0 context.Context, _a1 *admin.NodeExecutionEventRequest) *AdminServiceServer_CreateNodeEvent {
	c_call := _m.On("CreateNodeEvent", _a0, _a1)
	return &AdminServiceServer_CreateNodeEvent{Call: c_call}
}

func (_m *AdminServiceServer) OnCreateNodeEventMatch(matchers ...interface{}) *AdminServiceServer_CreateNodeEvent {
	c_call := _m.On("CreateNodeEvent", matchers...)
	return &AdminServiceServer_CreateNodeEvent{Call: c_call}
}

// CreateNodeEvent provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) CreateNodeEvent(_a0 context.Context, _a1 *admin.NodeExecutionEventRequest) (*admin.NodeExecutionEventResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.NodeExecutionEventResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.NodeExecutionEventRequest) *admin.NodeExecutionEventResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.NodeExecutionEventResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.NodeExecutionEventRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_CreateTask struct {
	*mock.Call
}

func (_m AdminServiceServer_CreateTask) Return(_a0 *admin.TaskCreateResponse, _a1 error) *AdminServiceServer_CreateTask {
	return &AdminServiceServer_CreateTask{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnCreateTask(_a0 context.Context, _a1 *admin.TaskCreateRequest) *AdminServiceServer_CreateTask {
	c_call := _m.On("CreateTask", _a0, _a1)
	return &AdminServiceServer_CreateTask{Call: c_call}
}

func (_m *AdminServiceServer) OnCreateTaskMatch(matchers ...interface{}) *AdminServiceServer_CreateTask {
	c_call := _m.On("CreateTask", matchers...)
	return &AdminServiceServer_CreateTask{Call: c_call}
}

// CreateTask provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) CreateTask(_a0 context.Context, _a1 *admin.TaskCreateRequest) (*admin.TaskCreateResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.TaskCreateResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.TaskCreateRequest) *admin.TaskCreateResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.TaskCreateResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.TaskCreateRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_CreateTaskEvent struct {
	*mock.Call
}

func (_m AdminServiceServer_CreateTaskEvent) Return(_a0 *admin.TaskExecutionEventResponse, _a1 error) *AdminServiceServer_CreateTaskEvent {
	return &AdminServiceServer_CreateTaskEvent{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnCreateTaskEvent(_a0 context.Context, _a1 *admin.TaskExecutionEventRequest) *AdminServiceServer_CreateTaskEvent {
	c_call := _m.On("CreateTaskEvent", _a0, _a1)
	return &AdminServiceServer_CreateTaskEvent{Call: c_call}
}

func (_m *AdminServiceServer) OnCreateTaskEventMatch(matchers ...interface{}) *AdminServiceServer_CreateTaskEvent {
	c_call := _m.On("CreateTaskEvent", matchers...)
	return &AdminServiceServer_CreateTaskEvent{Call: c_call}
}

// CreateTaskEvent provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) CreateTaskEvent(_a0 context.Context, _a1 *admin.TaskExecutionEventRequest) (*admin.TaskExecutionEventResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.TaskExecutionEventResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.TaskExecutionEventRequest) *admin.TaskExecutionEventResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.TaskExecutionEventResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.TaskExecutionEventRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_CreateWorkflow struct {
	*mock.Call
}

func (_m AdminServiceServer_CreateWorkflow) Return(_a0 *admin.WorkflowCreateResponse, _a1 error) *AdminServiceServer_CreateWorkflow {
	return &AdminServiceServer_CreateWorkflow{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnCreateWorkflow(_a0 context.Context, _a1 *admin.WorkflowCreateRequest) *AdminServiceServer_CreateWorkflow {
	c_call := _m.On("CreateWorkflow", _a0, _a1)
	return &AdminServiceServer_CreateWorkflow{Call: c_call}
}

func (_m *AdminServiceServer) OnCreateWorkflowMatch(matchers ...interface{}) *AdminServiceServer_CreateWorkflow {
	c_call := _m.On("CreateWorkflow", matchers...)
	return &AdminServiceServer_CreateWorkflow{Call: c_call}
}

// CreateWorkflow provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) CreateWorkflow(_a0 context.Context, _a1 *admin.WorkflowCreateRequest) (*admin.WorkflowCreateResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.WorkflowCreateResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.WorkflowCreateRequest) *admin.WorkflowCreateResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.WorkflowCreateResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.WorkflowCreateRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_CreateWorkflowEvent struct {
	*mock.Call
}

func (_m AdminServiceServer_CreateWorkflowEvent) Return(_a0 *admin.WorkflowExecutionEventResponse, _a1 error) *AdminServiceServer_CreateWorkflowEvent {
	return &AdminServiceServer_CreateWorkflowEvent{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnCreateWorkflowEvent(_a0 context.Context, _a1 *admin.WorkflowExecutionEventRequest) *AdminServiceServer_CreateWorkflowEvent {
	c_call := _m.On("CreateWorkflowEvent", _a0, _a1)
	return &AdminServiceServer_CreateWorkflowEvent{Call: c_call}
}

func (_m *AdminServiceServer) OnCreateWorkflowEventMatch(matchers ...interface{}) *AdminServiceServer_CreateWorkflowEvent {
	c_call := _m.On("CreateWorkflowEvent", matchers...)
	return &AdminServiceServer_CreateWorkflowEvent{Call: c_call}
}

// CreateWorkflowEvent provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) CreateWorkflowEvent(_a0 context.Context, _a1 *admin.WorkflowExecutionEventRequest) (*admin.WorkflowExecutionEventResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.WorkflowExecutionEventResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.WorkflowExecutionEventRequest) *admin.WorkflowExecutionEventResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.WorkflowExecutionEventResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.WorkflowExecutionEventRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_DeleteProjectAttributes struct {
	*mock.Call
}

func (_m AdminServiceServer_DeleteProjectAttributes) Return(_a0 *admin.ProjectAttributesDeleteResponse, _a1 error) *AdminServiceServer_DeleteProjectAttributes {
	return &AdminServiceServer_DeleteProjectAttributes{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnDeleteProjectAttributes(_a0 context.Context, _a1 *admin.ProjectAttributesDeleteRequest) *AdminServiceServer_DeleteProjectAttributes {
	c_call := _m.On("DeleteProjectAttributes", _a0, _a1)
	return &AdminServiceServer_DeleteProjectAttributes{Call: c_call}
}

func (_m *AdminServiceServer) OnDeleteProjectAttributesMatch(matchers ...interface{}) *AdminServiceServer_DeleteProjectAttributes {
	c_call := _m.On("DeleteProjectAttributes", matchers...)
	return &AdminServiceServer_DeleteProjectAttributes{Call: c_call}
}

// DeleteProjectAttributes provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) DeleteProjectAttributes(_a0 context.Context, _a1 *admin.ProjectAttributesDeleteRequest) (*admin.ProjectAttributesDeleteResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.ProjectAttributesDeleteResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ProjectAttributesDeleteRequest) *admin.ProjectAttributesDeleteResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.ProjectAttributesDeleteResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.ProjectAttributesDeleteRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_DeleteProjectDomainAttributes struct {
	*mock.Call
}

func (_m AdminServiceServer_DeleteProjectDomainAttributes) Return(_a0 *admin.ProjectDomainAttributesDeleteResponse, _a1 error) *AdminServiceServer_DeleteProjectDomainAttributes {
	return &AdminServiceServer_DeleteProjectDomainAttributes{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnDeleteProjectDomainAttributes(_a0 context.Context, _a1 *admin.ProjectDomainAttributesDeleteRequest) *AdminServiceServer_DeleteProjectDomainAttributes {
	c_call := _m.On("DeleteProjectDomainAttributes", _a0, _a1)
	return &AdminServiceServer_DeleteProjectDomainAttributes{Call: c_call}
}

func (_m *AdminServiceServer) OnDeleteProjectDomainAttributesMatch(matchers ...interface{}) *AdminServiceServer_DeleteProjectDomainAttributes {
	c_call := _m.On("DeleteProjectDomainAttributes", matchers...)
	return &AdminServiceServer_DeleteProjectDomainAttributes{Call: c_call}
}

// DeleteProjectDomainAttributes provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) DeleteProjectDomainAttributes(_a0 context.Context, _a1 *admin.ProjectDomainAttributesDeleteRequest) (*admin.ProjectDomainAttributesDeleteResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.ProjectDomainAttributesDeleteResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ProjectDomainAttributesDeleteRequest) *admin.ProjectDomainAttributesDeleteResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.ProjectDomainAttributesDeleteResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.ProjectDomainAttributesDeleteRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_DeleteWorkflowAttributes struct {
	*mock.Call
}

func (_m AdminServiceServer_DeleteWorkflowAttributes) Return(_a0 *admin.WorkflowAttributesDeleteResponse, _a1 error) *AdminServiceServer_DeleteWorkflowAttributes {
	return &AdminServiceServer_DeleteWorkflowAttributes{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnDeleteWorkflowAttributes(_a0 context.Context, _a1 *admin.WorkflowAttributesDeleteRequest) *AdminServiceServer_DeleteWorkflowAttributes {
	c_call := _m.On("DeleteWorkflowAttributes", _a0, _a1)
	return &AdminServiceServer_DeleteWorkflowAttributes{Call: c_call}
}

func (_m *AdminServiceServer) OnDeleteWorkflowAttributesMatch(matchers ...interface{}) *AdminServiceServer_DeleteWorkflowAttributes {
	c_call := _m.On("DeleteWorkflowAttributes", matchers...)
	return &AdminServiceServer_DeleteWorkflowAttributes{Call: c_call}
}

// DeleteWorkflowAttributes provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) DeleteWorkflowAttributes(_a0 context.Context, _a1 *admin.WorkflowAttributesDeleteRequest) (*admin.WorkflowAttributesDeleteResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.WorkflowAttributesDeleteResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.WorkflowAttributesDeleteRequest) *admin.WorkflowAttributesDeleteResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.WorkflowAttributesDeleteResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.WorkflowAttributesDeleteRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_GetActiveLaunchPlan struct {
	*mock.Call
}

func (_m AdminServiceServer_GetActiveLaunchPlan) Return(_a0 *admin.LaunchPlan, _a1 error) *AdminServiceServer_GetActiveLaunchPlan {
	return &AdminServiceServer_GetActiveLaunchPlan{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnGetActiveLaunchPlan(_a0 context.Context, _a1 *admin.ActiveLaunchPlanRequest) *AdminServiceServer_GetActiveLaunchPlan {
	c_call := _m.On("GetActiveLaunchPlan", _a0, _a1)
	return &AdminServiceServer_GetActiveLaunchPlan{Call: c_call}
}

func (_m *AdminServiceServer) OnGetActiveLaunchPlanMatch(matchers ...interface{}) *AdminServiceServer_GetActiveLaunchPlan {
	c_call := _m.On("GetActiveLaunchPlan", matchers...)
	return &AdminServiceServer_GetActiveLaunchPlan{Call: c_call}
}

// GetActiveLaunchPlan provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) GetActiveLaunchPlan(_a0 context.Context, _a1 *admin.ActiveLaunchPlanRequest) (*admin.LaunchPlan, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.LaunchPlan
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ActiveLaunchPlanRequest) *admin.LaunchPlan); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.LaunchPlan)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.ActiveLaunchPlanRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_GetDescriptionEntity struct {
	*mock.Call
}

func (_m AdminServiceServer_GetDescriptionEntity) Return(_a0 *admin.DescriptionEntity, _a1 error) *AdminServiceServer_GetDescriptionEntity {
	return &AdminServiceServer_GetDescriptionEntity{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnGetDescriptionEntity(_a0 context.Context, _a1 *admin.ObjectGetRequest) *AdminServiceServer_GetDescriptionEntity {
	c_call := _m.On("GetDescriptionEntity", _a0, _a1)
	return &AdminServiceServer_GetDescriptionEntity{Call: c_call}
}

func (_m *AdminServiceServer) OnGetDescriptionEntityMatch(matchers ...interface{}) *AdminServiceServer_GetDescriptionEntity {
	c_call := _m.On("GetDescriptionEntity", matchers...)
	return &AdminServiceServer_GetDescriptionEntity{Call: c_call}
}

// GetDescriptionEntity provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) GetDescriptionEntity(_a0 context.Context, _a1 *admin.ObjectGetRequest) (*admin.DescriptionEntity, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.DescriptionEntity
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ObjectGetRequest) *admin.DescriptionEntity); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.DescriptionEntity)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.ObjectGetRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_GetDynamicNodeWorkflow struct {
	*mock.Call
}

func (_m AdminServiceServer_GetDynamicNodeWorkflow) Return(_a0 *admin.DynamicNodeWorkflowResponse, _a1 error) *AdminServiceServer_GetDynamicNodeWorkflow {
	return &AdminServiceServer_GetDynamicNodeWorkflow{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnGetDynamicNodeWorkflow(_a0 context.Context, _a1 *admin.GetDynamicNodeWorkflowRequest) *AdminServiceServer_GetDynamicNodeWorkflow {
	c_call := _m.On("GetDynamicNodeWorkflow", _a0, _a1)
	return &AdminServiceServer_GetDynamicNodeWorkflow{Call: c_call}
}

func (_m *AdminServiceServer) OnGetDynamicNodeWorkflowMatch(matchers ...interface{}) *AdminServiceServer_GetDynamicNodeWorkflow {
	c_call := _m.On("GetDynamicNodeWorkflow", matchers...)
	return &AdminServiceServer_GetDynamicNodeWorkflow{Call: c_call}
}

// GetDynamicNodeWorkflow provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) GetDynamicNodeWorkflow(_a0 context.Context, _a1 *admin.GetDynamicNodeWorkflowRequest) (*admin.DynamicNodeWorkflowResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.DynamicNodeWorkflowResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.GetDynamicNodeWorkflowRequest) *admin.DynamicNodeWorkflowResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.DynamicNodeWorkflowResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.GetDynamicNodeWorkflowRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_GetExecution struct {
	*mock.Call
}

func (_m AdminServiceServer_GetExecution) Return(_a0 *admin.Execution, _a1 error) *AdminServiceServer_GetExecution {
	return &AdminServiceServer_GetExecution{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnGetExecution(_a0 context.Context, _a1 *admin.WorkflowExecutionGetRequest) *AdminServiceServer_GetExecution {
	c_call := _m.On("GetExecution", _a0, _a1)
	return &AdminServiceServer_GetExecution{Call: c_call}
}

func (_m *AdminServiceServer) OnGetExecutionMatch(matchers ...interface{}) *AdminServiceServer_GetExecution {
	c_call := _m.On("GetExecution", matchers...)
	return &AdminServiceServer_GetExecution{Call: c_call}
}

// GetExecution provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) GetExecution(_a0 context.Context, _a1 *admin.WorkflowExecutionGetRequest) (*admin.Execution, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.Execution
	if rf, ok := ret.Get(0).(func(context.Context, *admin.WorkflowExecutionGetRequest) *admin.Execution); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.Execution)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.WorkflowExecutionGetRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_GetExecutionData struct {
	*mock.Call
}

func (_m AdminServiceServer_GetExecutionData) Return(_a0 *admin.WorkflowExecutionGetDataResponse, _a1 error) *AdminServiceServer_GetExecutionData {
	return &AdminServiceServer_GetExecutionData{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnGetExecutionData(_a0 context.Context, _a1 *admin.WorkflowExecutionGetDataRequest) *AdminServiceServer_GetExecutionData {
	c_call := _m.On("GetExecutionData", _a0, _a1)
	return &AdminServiceServer_GetExecutionData{Call: c_call}
}

func (_m *AdminServiceServer) OnGetExecutionDataMatch(matchers ...interface{}) *AdminServiceServer_GetExecutionData {
	c_call := _m.On("GetExecutionData", matchers...)
	return &AdminServiceServer_GetExecutionData{Call: c_call}
}

// GetExecutionData provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) GetExecutionData(_a0 context.Context, _a1 *admin.WorkflowExecutionGetDataRequest) (*admin.WorkflowExecutionGetDataResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.WorkflowExecutionGetDataResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.WorkflowExecutionGetDataRequest) *admin.WorkflowExecutionGetDataResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.WorkflowExecutionGetDataResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.WorkflowExecutionGetDataRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_GetExecutionMetrics struct {
	*mock.Call
}

func (_m AdminServiceServer_GetExecutionMetrics) Return(_a0 *admin.WorkflowExecutionGetMetricsResponse, _a1 error) *AdminServiceServer_GetExecutionMetrics {
	return &AdminServiceServer_GetExecutionMetrics{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnGetExecutionMetrics(_a0 context.Context, _a1 *admin.WorkflowExecutionGetMetricsRequest) *AdminServiceServer_GetExecutionMetrics {
	c_call := _m.On("GetExecutionMetrics", _a0, _a1)
	return &AdminServiceServer_GetExecutionMetrics{Call: c_call}
}

func (_m *AdminServiceServer) OnGetExecutionMetricsMatch(matchers ...interface{}) *AdminServiceServer_GetExecutionMetrics {
	c_call := _m.On("GetExecutionMetrics", matchers...)
	return &AdminServiceServer_GetExecutionMetrics{Call: c_call}
}

// GetExecutionMetrics provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) GetExecutionMetrics(_a0 context.Context, _a1 *admin.WorkflowExecutionGetMetricsRequest) (*admin.WorkflowExecutionGetMetricsResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.WorkflowExecutionGetMetricsResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.WorkflowExecutionGetMetricsRequest) *admin.WorkflowExecutionGetMetricsResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.WorkflowExecutionGetMetricsResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.WorkflowExecutionGetMetricsRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_GetLaunchPlan struct {
	*mock.Call
}

func (_m AdminServiceServer_GetLaunchPlan) Return(_a0 *admin.LaunchPlan, _a1 error) *AdminServiceServer_GetLaunchPlan {
	return &AdminServiceServer_GetLaunchPlan{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnGetLaunchPlan(_a0 context.Context, _a1 *admin.ObjectGetRequest) *AdminServiceServer_GetLaunchPlan {
	c_call := _m.On("GetLaunchPlan", _a0, _a1)
	return &AdminServiceServer_GetLaunchPlan{Call: c_call}
}

func (_m *AdminServiceServer) OnGetLaunchPlanMatch(matchers ...interface{}) *AdminServiceServer_GetLaunchPlan {
	c_call := _m.On("GetLaunchPlan", matchers...)
	return &AdminServiceServer_GetLaunchPlan{Call: c_call}
}

// GetLaunchPlan provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) GetLaunchPlan(_a0 context.Context, _a1 *admin.ObjectGetRequest) (*admin.LaunchPlan, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.LaunchPlan
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ObjectGetRequest) *admin.LaunchPlan); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.LaunchPlan)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.ObjectGetRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_GetNamedEntity struct {
	*mock.Call
}

func (_m AdminServiceServer_GetNamedEntity) Return(_a0 *admin.NamedEntity, _a1 error) *AdminServiceServer_GetNamedEntity {
	return &AdminServiceServer_GetNamedEntity{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnGetNamedEntity(_a0 context.Context, _a1 *admin.NamedEntityGetRequest) *AdminServiceServer_GetNamedEntity {
	c_call := _m.On("GetNamedEntity", _a0, _a1)
	return &AdminServiceServer_GetNamedEntity{Call: c_call}
}

func (_m *AdminServiceServer) OnGetNamedEntityMatch(matchers ...interface{}) *AdminServiceServer_GetNamedEntity {
	c_call := _m.On("GetNamedEntity", matchers...)
	return &AdminServiceServer_GetNamedEntity{Call: c_call}
}

// GetNamedEntity provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) GetNamedEntity(_a0 context.Context, _a1 *admin.NamedEntityGetRequest) (*admin.NamedEntity, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.NamedEntity
	if rf, ok := ret.Get(0).(func(context.Context, *admin.NamedEntityGetRequest) *admin.NamedEntity); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.NamedEntity)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.NamedEntityGetRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_GetNodeExecution struct {
	*mock.Call
}

func (_m AdminServiceServer_GetNodeExecution) Return(_a0 *admin.NodeExecution, _a1 error) *AdminServiceServer_GetNodeExecution {
	return &AdminServiceServer_GetNodeExecution{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnGetNodeExecution(_a0 context.Context, _a1 *admin.NodeExecutionGetRequest) *AdminServiceServer_GetNodeExecution {
	c_call := _m.On("GetNodeExecution", _a0, _a1)
	return &AdminServiceServer_GetNodeExecution{Call: c_call}
}

func (_m *AdminServiceServer) OnGetNodeExecutionMatch(matchers ...interface{}) *AdminServiceServer_GetNodeExecution {
	c_call := _m.On("GetNodeExecution", matchers...)
	return &AdminServiceServer_GetNodeExecution{Call: c_call}
}

// GetNodeExecution provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) GetNodeExecution(_a0 context.Context, _a1 *admin.NodeExecutionGetRequest) (*admin.NodeExecution, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.NodeExecution
	if rf, ok := ret.Get(0).(func(context.Context, *admin.NodeExecutionGetRequest) *admin.NodeExecution); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.NodeExecution)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.NodeExecutionGetRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_GetNodeExecutionData struct {
	*mock.Call
}

func (_m AdminServiceServer_GetNodeExecutionData) Return(_a0 *admin.NodeExecutionGetDataResponse, _a1 error) *AdminServiceServer_GetNodeExecutionData {
	return &AdminServiceServer_GetNodeExecutionData{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnGetNodeExecutionData(_a0 context.Context, _a1 *admin.NodeExecutionGetDataRequest) *AdminServiceServer_GetNodeExecutionData {
	c_call := _m.On("GetNodeExecutionData", _a0, _a1)
	return &AdminServiceServer_GetNodeExecutionData{Call: c_call}
}

func (_m *AdminServiceServer) OnGetNodeExecutionDataMatch(matchers ...interface{}) *AdminServiceServer_GetNodeExecutionData {
	c_call := _m.On("GetNodeExecutionData", matchers...)
	return &AdminServiceServer_GetNodeExecutionData{Call: c_call}
}

// GetNodeExecutionData provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) GetNodeExecutionData(_a0 context.Context, _a1 *admin.NodeExecutionGetDataRequest) (*admin.NodeExecutionGetDataResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.NodeExecutionGetDataResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.NodeExecutionGetDataRequest) *admin.NodeExecutionGetDataResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.NodeExecutionGetDataResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.NodeExecutionGetDataRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_GetProjectAttributes struct {
	*mock.Call
}

func (_m AdminServiceServer_GetProjectAttributes) Return(_a0 *admin.ProjectAttributesGetResponse, _a1 error) *AdminServiceServer_GetProjectAttributes {
	return &AdminServiceServer_GetProjectAttributes{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnGetProjectAttributes(_a0 context.Context, _a1 *admin.ProjectAttributesGetRequest) *AdminServiceServer_GetProjectAttributes {
	c_call := _m.On("GetProjectAttributes", _a0, _a1)
	return &AdminServiceServer_GetProjectAttributes{Call: c_call}
}

func (_m *AdminServiceServer) OnGetProjectAttributesMatch(matchers ...interface{}) *AdminServiceServer_GetProjectAttributes {
	c_call := _m.On("GetProjectAttributes", matchers...)
	return &AdminServiceServer_GetProjectAttributes{Call: c_call}
}

// GetProjectAttributes provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) GetProjectAttributes(_a0 context.Context, _a1 *admin.ProjectAttributesGetRequest) (*admin.ProjectAttributesGetResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.ProjectAttributesGetResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ProjectAttributesGetRequest) *admin.ProjectAttributesGetResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.ProjectAttributesGetResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.ProjectAttributesGetRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_GetProjectDomainAttributes struct {
	*mock.Call
}

func (_m AdminServiceServer_GetProjectDomainAttributes) Return(_a0 *admin.ProjectDomainAttributesGetResponse, _a1 error) *AdminServiceServer_GetProjectDomainAttributes {
	return &AdminServiceServer_GetProjectDomainAttributes{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnGetProjectDomainAttributes(_a0 context.Context, _a1 *admin.ProjectDomainAttributesGetRequest) *AdminServiceServer_GetProjectDomainAttributes {
	c_call := _m.On("GetProjectDomainAttributes", _a0, _a1)
	return &AdminServiceServer_GetProjectDomainAttributes{Call: c_call}
}

func (_m *AdminServiceServer) OnGetProjectDomainAttributesMatch(matchers ...interface{}) *AdminServiceServer_GetProjectDomainAttributes {
	c_call := _m.On("GetProjectDomainAttributes", matchers...)
	return &AdminServiceServer_GetProjectDomainAttributes{Call: c_call}
}

// GetProjectDomainAttributes provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) GetProjectDomainAttributes(_a0 context.Context, _a1 *admin.ProjectDomainAttributesGetRequest) (*admin.ProjectDomainAttributesGetResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.ProjectDomainAttributesGetResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ProjectDomainAttributesGetRequest) *admin.ProjectDomainAttributesGetResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.ProjectDomainAttributesGetResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.ProjectDomainAttributesGetRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_GetTask struct {
	*mock.Call
}

func (_m AdminServiceServer_GetTask) Return(_a0 *admin.Task, _a1 error) *AdminServiceServer_GetTask {
	return &AdminServiceServer_GetTask{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnGetTask(_a0 context.Context, _a1 *admin.ObjectGetRequest) *AdminServiceServer_GetTask {
	c_call := _m.On("GetTask", _a0, _a1)
	return &AdminServiceServer_GetTask{Call: c_call}
}

func (_m *AdminServiceServer) OnGetTaskMatch(matchers ...interface{}) *AdminServiceServer_GetTask {
	c_call := _m.On("GetTask", matchers...)
	return &AdminServiceServer_GetTask{Call: c_call}
}

// GetTask provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) GetTask(_a0 context.Context, _a1 *admin.ObjectGetRequest) (*admin.Task, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.Task
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ObjectGetRequest) *admin.Task); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.Task)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.ObjectGetRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_GetTaskExecution struct {
	*mock.Call
}

func (_m AdminServiceServer_GetTaskExecution) Return(_a0 *admin.TaskExecution, _a1 error) *AdminServiceServer_GetTaskExecution {
	return &AdminServiceServer_GetTaskExecution{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnGetTaskExecution(_a0 context.Context, _a1 *admin.TaskExecutionGetRequest) *AdminServiceServer_GetTaskExecution {
	c_call := _m.On("GetTaskExecution", _a0, _a1)
	return &AdminServiceServer_GetTaskExecution{Call: c_call}
}

func (_m *AdminServiceServer) OnGetTaskExecutionMatch(matchers ...interface{}) *AdminServiceServer_GetTaskExecution {
	c_call := _m.On("GetTaskExecution", matchers...)
	return &AdminServiceServer_GetTaskExecution{Call: c_call}
}

// GetTaskExecution provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) GetTaskExecution(_a0 context.Context, _a1 *admin.TaskExecutionGetRequest) (*admin.TaskExecution, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.TaskExecution
	if rf, ok := ret.Get(0).(func(context.Context, *admin.TaskExecutionGetRequest) *admin.TaskExecution); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.TaskExecution)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.TaskExecutionGetRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_GetTaskExecutionData struct {
	*mock.Call
}

func (_m AdminServiceServer_GetTaskExecutionData) Return(_a0 *admin.TaskExecutionGetDataResponse, _a1 error) *AdminServiceServer_GetTaskExecutionData {
	return &AdminServiceServer_GetTaskExecutionData{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnGetTaskExecutionData(_a0 context.Context, _a1 *admin.TaskExecutionGetDataRequest) *AdminServiceServer_GetTaskExecutionData {
	c_call := _m.On("GetTaskExecutionData", _a0, _a1)
	return &AdminServiceServer_GetTaskExecutionData{Call: c_call}
}

func (_m *AdminServiceServer) OnGetTaskExecutionDataMatch(matchers ...interface{}) *AdminServiceServer_GetTaskExecutionData {
	c_call := _m.On("GetTaskExecutionData", matchers...)
	return &AdminServiceServer_GetTaskExecutionData{Call: c_call}
}

// GetTaskExecutionData provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) GetTaskExecutionData(_a0 context.Context, _a1 *admin.TaskExecutionGetDataRequest) (*admin.TaskExecutionGetDataResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.TaskExecutionGetDataResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.TaskExecutionGetDataRequest) *admin.TaskExecutionGetDataResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.TaskExecutionGetDataResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.TaskExecutionGetDataRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_GetVersion struct {
	*mock.Call
}

func (_m AdminServiceServer_GetVersion) Return(_a0 *admin.GetVersionResponse, _a1 error) *AdminServiceServer_GetVersion {
	return &AdminServiceServer_GetVersion{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnGetVersion(_a0 context.Context, _a1 *admin.GetVersionRequest) *AdminServiceServer_GetVersion {
	c_call := _m.On("GetVersion", _a0, _a1)
	return &AdminServiceServer_GetVersion{Call: c_call}
}

func (_m *AdminServiceServer) OnGetVersionMatch(matchers ...interface{}) *AdminServiceServer_GetVersion {
	c_call := _m.On("GetVersion", matchers...)
	return &AdminServiceServer_GetVersion{Call: c_call}
}

// GetVersion provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) GetVersion(_a0 context.Context, _a1 *admin.GetVersionRequest) (*admin.GetVersionResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.GetVersionResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.GetVersionRequest) *admin.GetVersionResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.GetVersionResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.GetVersionRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_GetWorkflow struct {
	*mock.Call
}

func (_m AdminServiceServer_GetWorkflow) Return(_a0 *admin.Workflow, _a1 error) *AdminServiceServer_GetWorkflow {
	return &AdminServiceServer_GetWorkflow{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnGetWorkflow(_a0 context.Context, _a1 *admin.ObjectGetRequest) *AdminServiceServer_GetWorkflow {
	c_call := _m.On("GetWorkflow", _a0, _a1)
	return &AdminServiceServer_GetWorkflow{Call: c_call}
}

func (_m *AdminServiceServer) OnGetWorkflowMatch(matchers ...interface{}) *AdminServiceServer_GetWorkflow {
	c_call := _m.On("GetWorkflow", matchers...)
	return &AdminServiceServer_GetWorkflow{Call: c_call}
}

// GetWorkflow provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) GetWorkflow(_a0 context.Context, _a1 *admin.ObjectGetRequest) (*admin.Workflow, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.Workflow
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ObjectGetRequest) *admin.Workflow); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.Workflow)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.ObjectGetRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_GetWorkflowAttributes struct {
	*mock.Call
}

func (_m AdminServiceServer_GetWorkflowAttributes) Return(_a0 *admin.WorkflowAttributesGetResponse, _a1 error) *AdminServiceServer_GetWorkflowAttributes {
	return &AdminServiceServer_GetWorkflowAttributes{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnGetWorkflowAttributes(_a0 context.Context, _a1 *admin.WorkflowAttributesGetRequest) *AdminServiceServer_GetWorkflowAttributes {
	c_call := _m.On("GetWorkflowAttributes", _a0, _a1)
	return &AdminServiceServer_GetWorkflowAttributes{Call: c_call}
}

func (_m *AdminServiceServer) OnGetWorkflowAttributesMatch(matchers ...interface{}) *AdminServiceServer_GetWorkflowAttributes {
	c_call := _m.On("GetWorkflowAttributes", matchers...)
	return &AdminServiceServer_GetWorkflowAttributes{Call: c_call}
}

// GetWorkflowAttributes provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) GetWorkflowAttributes(_a0 context.Context, _a1 *admin.WorkflowAttributesGetRequest) (*admin.WorkflowAttributesGetResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.WorkflowAttributesGetResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.WorkflowAttributesGetRequest) *admin.WorkflowAttributesGetResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.WorkflowAttributesGetResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.WorkflowAttributesGetRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_ListActiveLaunchPlans struct {
	*mock.Call
}

func (_m AdminServiceServer_ListActiveLaunchPlans) Return(_a0 *admin.LaunchPlanList, _a1 error) *AdminServiceServer_ListActiveLaunchPlans {
	return &AdminServiceServer_ListActiveLaunchPlans{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnListActiveLaunchPlans(_a0 context.Context, _a1 *admin.ActiveLaunchPlanListRequest) *AdminServiceServer_ListActiveLaunchPlans {
	c_call := _m.On("ListActiveLaunchPlans", _a0, _a1)
	return &AdminServiceServer_ListActiveLaunchPlans{Call: c_call}
}

func (_m *AdminServiceServer) OnListActiveLaunchPlansMatch(matchers ...interface{}) *AdminServiceServer_ListActiveLaunchPlans {
	c_call := _m.On("ListActiveLaunchPlans", matchers...)
	return &AdminServiceServer_ListActiveLaunchPlans{Call: c_call}
}

// ListActiveLaunchPlans provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) ListActiveLaunchPlans(_a0 context.Context, _a1 *admin.ActiveLaunchPlanListRequest) (*admin.LaunchPlanList, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.LaunchPlanList
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ActiveLaunchPlanListRequest) *admin.LaunchPlanList); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.LaunchPlanList)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.ActiveLaunchPlanListRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_ListDescriptionEntities struct {
	*mock.Call
}

func (_m AdminServiceServer_ListDescriptionEntities) Return(_a0 *admin.DescriptionEntityList, _a1 error) *AdminServiceServer_ListDescriptionEntities {
	return &AdminServiceServer_ListDescriptionEntities{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnListDescriptionEntities(_a0 context.Context, _a1 *admin.DescriptionEntityListRequest) *AdminServiceServer_ListDescriptionEntities {
	c_call := _m.On("ListDescriptionEntities", _a0, _a1)
	return &AdminServiceServer_ListDescriptionEntities{Call: c_call}
}

func (_m *AdminServiceServer) OnListDescriptionEntitiesMatch(matchers ...interface{}) *AdminServiceServer_ListDescriptionEntities {
	c_call := _m.On("ListDescriptionEntities", matchers...)
	return &AdminServiceServer_ListDescriptionEntities{Call: c_call}
}

// ListDescriptionEntities provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) ListDescriptionEntities(_a0 context.Context, _a1 *admin.DescriptionEntityListRequest) (*admin.DescriptionEntityList, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.DescriptionEntityList
	if rf, ok := ret.Get(0).(func(context.Context, *admin.DescriptionEntityListRequest) *admin.DescriptionEntityList); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.DescriptionEntityList)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.DescriptionEntityListRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_ListExecutions struct {
	*mock.Call
}

func (_m AdminServiceServer_ListExecutions) Return(_a0 *admin.ExecutionList, _a1 error) *AdminServiceServer_ListExecutions {
	return &AdminServiceServer_ListExecutions{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnListExecutions(_a0 context.Context, _a1 *admin.ResourceListRequest) *AdminServiceServer_ListExecutions {
	c_call := _m.On("ListExecutions", _a0, _a1)
	return &AdminServiceServer_ListExecutions{Call: c_call}
}

func (_m *AdminServiceServer) OnListExecutionsMatch(matchers ...interface{}) *AdminServiceServer_ListExecutions {
	c_call := _m.On("ListExecutions", matchers...)
	return &AdminServiceServer_ListExecutions{Call: c_call}
}

// ListExecutions provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) ListExecutions(_a0 context.Context, _a1 *admin.ResourceListRequest) (*admin.ExecutionList, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.ExecutionList
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ResourceListRequest) *admin.ExecutionList); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.ExecutionList)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.ResourceListRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_ListLaunchPlanIds struct {
	*mock.Call
}

func (_m AdminServiceServer_ListLaunchPlanIds) Return(_a0 *admin.NamedEntityIdentifierList, _a1 error) *AdminServiceServer_ListLaunchPlanIds {
	return &AdminServiceServer_ListLaunchPlanIds{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnListLaunchPlanIds(_a0 context.Context, _a1 *admin.NamedEntityIdentifierListRequest) *AdminServiceServer_ListLaunchPlanIds {
	c_call := _m.On("ListLaunchPlanIds", _a0, _a1)
	return &AdminServiceServer_ListLaunchPlanIds{Call: c_call}
}

func (_m *AdminServiceServer) OnListLaunchPlanIdsMatch(matchers ...interface{}) *AdminServiceServer_ListLaunchPlanIds {
	c_call := _m.On("ListLaunchPlanIds", matchers...)
	return &AdminServiceServer_ListLaunchPlanIds{Call: c_call}
}

// ListLaunchPlanIds provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) ListLaunchPlanIds(_a0 context.Context, _a1 *admin.NamedEntityIdentifierListRequest) (*admin.NamedEntityIdentifierList, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.NamedEntityIdentifierList
	if rf, ok := ret.Get(0).(func(context.Context, *admin.NamedEntityIdentifierListRequest) *admin.NamedEntityIdentifierList); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.NamedEntityIdentifierList)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.NamedEntityIdentifierListRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_ListLaunchPlans struct {
	*mock.Call
}

func (_m AdminServiceServer_ListLaunchPlans) Return(_a0 *admin.LaunchPlanList, _a1 error) *AdminServiceServer_ListLaunchPlans {
	return &AdminServiceServer_ListLaunchPlans{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnListLaunchPlans(_a0 context.Context, _a1 *admin.ResourceListRequest) *AdminServiceServer_ListLaunchPlans {
	c_call := _m.On("ListLaunchPlans", _a0, _a1)
	return &AdminServiceServer_ListLaunchPlans{Call: c_call}
}

func (_m *AdminServiceServer) OnListLaunchPlansMatch(matchers ...interface{}) *AdminServiceServer_ListLaunchPlans {
	c_call := _m.On("ListLaunchPlans", matchers...)
	return &AdminServiceServer_ListLaunchPlans{Call: c_call}
}

// ListLaunchPlans provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) ListLaunchPlans(_a0 context.Context, _a1 *admin.ResourceListRequest) (*admin.LaunchPlanList, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.LaunchPlanList
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ResourceListRequest) *admin.LaunchPlanList); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.LaunchPlanList)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.ResourceListRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_ListMatchableAttributes struct {
	*mock.Call
}

func (_m AdminServiceServer_ListMatchableAttributes) Return(_a0 *admin.ListMatchableAttributesResponse, _a1 error) *AdminServiceServer_ListMatchableAttributes {
	return &AdminServiceServer_ListMatchableAttributes{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnListMatchableAttributes(_a0 context.Context, _a1 *admin.ListMatchableAttributesRequest) *AdminServiceServer_ListMatchableAttributes {
	c_call := _m.On("ListMatchableAttributes", _a0, _a1)
	return &AdminServiceServer_ListMatchableAttributes{Call: c_call}
}

func (_m *AdminServiceServer) OnListMatchableAttributesMatch(matchers ...interface{}) *AdminServiceServer_ListMatchableAttributes {
	c_call := _m.On("ListMatchableAttributes", matchers...)
	return &AdminServiceServer_ListMatchableAttributes{Call: c_call}
}

// ListMatchableAttributes provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) ListMatchableAttributes(_a0 context.Context, _a1 *admin.ListMatchableAttributesRequest) (*admin.ListMatchableAttributesResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.ListMatchableAttributesResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ListMatchableAttributesRequest) *admin.ListMatchableAttributesResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.ListMatchableAttributesResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.ListMatchableAttributesRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_ListNamedEntities struct {
	*mock.Call
}

func (_m AdminServiceServer_ListNamedEntities) Return(_a0 *admin.NamedEntityList, _a1 error) *AdminServiceServer_ListNamedEntities {
	return &AdminServiceServer_ListNamedEntities{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnListNamedEntities(_a0 context.Context, _a1 *admin.NamedEntityListRequest) *AdminServiceServer_ListNamedEntities {
	c_call := _m.On("ListNamedEntities", _a0, _a1)
	return &AdminServiceServer_ListNamedEntities{Call: c_call}
}

func (_m *AdminServiceServer) OnListNamedEntitiesMatch(matchers ...interface{}) *AdminServiceServer_ListNamedEntities {
	c_call := _m.On("ListNamedEntities", matchers...)
	return &AdminServiceServer_ListNamedEntities{Call: c_call}
}

// ListNamedEntities provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) ListNamedEntities(_a0 context.Context, _a1 *admin.NamedEntityListRequest) (*admin.NamedEntityList, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.NamedEntityList
	if rf, ok := ret.Get(0).(func(context.Context, *admin.NamedEntityListRequest) *admin.NamedEntityList); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.NamedEntityList)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.NamedEntityListRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_ListNodeExecutions struct {
	*mock.Call
}

func (_m AdminServiceServer_ListNodeExecutions) Return(_a0 *admin.NodeExecutionList, _a1 error) *AdminServiceServer_ListNodeExecutions {
	return &AdminServiceServer_ListNodeExecutions{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnListNodeExecutions(_a0 context.Context, _a1 *admin.NodeExecutionListRequest) *AdminServiceServer_ListNodeExecutions {
	c_call := _m.On("ListNodeExecutions", _a0, _a1)
	return &AdminServiceServer_ListNodeExecutions{Call: c_call}
}

func (_m *AdminServiceServer) OnListNodeExecutionsMatch(matchers ...interface{}) *AdminServiceServer_ListNodeExecutions {
	c_call := _m.On("ListNodeExecutions", matchers...)
	return &AdminServiceServer_ListNodeExecutions{Call: c_call}
}

// ListNodeExecutions provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) ListNodeExecutions(_a0 context.Context, _a1 *admin.NodeExecutionListRequest) (*admin.NodeExecutionList, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.NodeExecutionList
	if rf, ok := ret.Get(0).(func(context.Context, *admin.NodeExecutionListRequest) *admin.NodeExecutionList); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.NodeExecutionList)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.NodeExecutionListRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_ListNodeExecutionsForTask struct {
	*mock.Call
}

func (_m AdminServiceServer_ListNodeExecutionsForTask) Return(_a0 *admin.NodeExecutionList, _a1 error) *AdminServiceServer_ListNodeExecutionsForTask {
	return &AdminServiceServer_ListNodeExecutionsForTask{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnListNodeExecutionsForTask(_a0 context.Context, _a1 *admin.NodeExecutionForTaskListRequest) *AdminServiceServer_ListNodeExecutionsForTask {
	c_call := _m.On("ListNodeExecutionsForTask", _a0, _a1)
	return &AdminServiceServer_ListNodeExecutionsForTask{Call: c_call}
}

func (_m *AdminServiceServer) OnListNodeExecutionsForTaskMatch(matchers ...interface{}) *AdminServiceServer_ListNodeExecutionsForTask {
	c_call := _m.On("ListNodeExecutionsForTask", matchers...)
	return &AdminServiceServer_ListNodeExecutionsForTask{Call: c_call}
}

// ListNodeExecutionsForTask provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) ListNodeExecutionsForTask(_a0 context.Context, _a1 *admin.NodeExecutionForTaskListRequest) (*admin.NodeExecutionList, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.NodeExecutionList
	if rf, ok := ret.Get(0).(func(context.Context, *admin.NodeExecutionForTaskListRequest) *admin.NodeExecutionList); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.NodeExecutionList)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.NodeExecutionForTaskListRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_ListProjects struct {
	*mock.Call
}

func (_m AdminServiceServer_ListProjects) Return(_a0 *admin.Projects, _a1 error) *AdminServiceServer_ListProjects {
	return &AdminServiceServer_ListProjects{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnListProjects(_a0 context.Context, _a1 *admin.ProjectListRequest) *AdminServiceServer_ListProjects {
	c_call := _m.On("ListProjects", _a0, _a1)
	return &AdminServiceServer_ListProjects{Call: c_call}
}

func (_m *AdminServiceServer) OnListProjectsMatch(matchers ...interface{}) *AdminServiceServer_ListProjects {
	c_call := _m.On("ListProjects", matchers...)
	return &AdminServiceServer_ListProjects{Call: c_call}
}

// ListProjects provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) ListProjects(_a0 context.Context, _a1 *admin.ProjectListRequest) (*admin.Projects, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.Projects
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ProjectListRequest) *admin.Projects); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.Projects)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.ProjectListRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_ListTaskExecutions struct {
	*mock.Call
}

func (_m AdminServiceServer_ListTaskExecutions) Return(_a0 *admin.TaskExecutionList, _a1 error) *AdminServiceServer_ListTaskExecutions {
	return &AdminServiceServer_ListTaskExecutions{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnListTaskExecutions(_a0 context.Context, _a1 *admin.TaskExecutionListRequest) *AdminServiceServer_ListTaskExecutions {
	c_call := _m.On("ListTaskExecutions", _a0, _a1)
	return &AdminServiceServer_ListTaskExecutions{Call: c_call}
}

func (_m *AdminServiceServer) OnListTaskExecutionsMatch(matchers ...interface{}) *AdminServiceServer_ListTaskExecutions {
	c_call := _m.On("ListTaskExecutions", matchers...)
	return &AdminServiceServer_ListTaskExecutions{Call: c_call}
}

// ListTaskExecutions provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) ListTaskExecutions(_a0 context.Context, _a1 *admin.TaskExecutionListRequest) (*admin.TaskExecutionList, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.TaskExecutionList
	if rf, ok := ret.Get(0).(func(context.Context, *admin.TaskExecutionListRequest) *admin.TaskExecutionList); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.TaskExecutionList)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.TaskExecutionListRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_ListTaskIds struct {
	*mock.Call
}

func (_m AdminServiceServer_ListTaskIds) Return(_a0 *admin.NamedEntityIdentifierList, _a1 error) *AdminServiceServer_ListTaskIds {
	return &AdminServiceServer_ListTaskIds{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnListTaskIds(_a0 context.Context, _a1 *admin.NamedEntityIdentifierListRequest) *AdminServiceServer_ListTaskIds {
	c_call := _m.On("ListTaskIds", _a0, _a1)
	return &AdminServiceServer_ListTaskIds{Call: c_call}
}

func (_m *AdminServiceServer) OnListTaskIdsMatch(matchers ...interface{}) *AdminServiceServer_ListTaskIds {
	c_call := _m.On("ListTaskIds", matchers...)
	return &AdminServiceServer_ListTaskIds{Call: c_call}
}

// ListTaskIds provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) ListTaskIds(_a0 context.Context, _a1 *admin.NamedEntityIdentifierListRequest) (*admin.NamedEntityIdentifierList, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.NamedEntityIdentifierList
	if rf, ok := ret.Get(0).(func(context.Context, *admin.NamedEntityIdentifierListRequest) *admin.NamedEntityIdentifierList); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.NamedEntityIdentifierList)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.NamedEntityIdentifierListRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_ListTasks struct {
	*mock.Call
}

func (_m AdminServiceServer_ListTasks) Return(_a0 *admin.TaskList, _a1 error) *AdminServiceServer_ListTasks {
	return &AdminServiceServer_ListTasks{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnListTasks(_a0 context.Context, _a1 *admin.ResourceListRequest) *AdminServiceServer_ListTasks {
	c_call := _m.On("ListTasks", _a0, _a1)
	return &AdminServiceServer_ListTasks{Call: c_call}
}

func (_m *AdminServiceServer) OnListTasksMatch(matchers ...interface{}) *AdminServiceServer_ListTasks {
	c_call := _m.On("ListTasks", matchers...)
	return &AdminServiceServer_ListTasks{Call: c_call}
}

// ListTasks provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) ListTasks(_a0 context.Context, _a1 *admin.ResourceListRequest) (*admin.TaskList, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.TaskList
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ResourceListRequest) *admin.TaskList); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.TaskList)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.ResourceListRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_ListWorkflowIds struct {
	*mock.Call
}

func (_m AdminServiceServer_ListWorkflowIds) Return(_a0 *admin.NamedEntityIdentifierList, _a1 error) *AdminServiceServer_ListWorkflowIds {
	return &AdminServiceServer_ListWorkflowIds{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnListWorkflowIds(_a0 context.Context, _a1 *admin.NamedEntityIdentifierListRequest) *AdminServiceServer_ListWorkflowIds {
	c_call := _m.On("ListWorkflowIds", _a0, _a1)
	return &AdminServiceServer_ListWorkflowIds{Call: c_call}
}

func (_m *AdminServiceServer) OnListWorkflowIdsMatch(matchers ...interface{}) *AdminServiceServer_ListWorkflowIds {
	c_call := _m.On("ListWorkflowIds", matchers...)
	return &AdminServiceServer_ListWorkflowIds{Call: c_call}
}

// ListWorkflowIds provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) ListWorkflowIds(_a0 context.Context, _a1 *admin.NamedEntityIdentifierListRequest) (*admin.NamedEntityIdentifierList, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.NamedEntityIdentifierList
	if rf, ok := ret.Get(0).(func(context.Context, *admin.NamedEntityIdentifierListRequest) *admin.NamedEntityIdentifierList); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.NamedEntityIdentifierList)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.NamedEntityIdentifierListRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_ListWorkflows struct {
	*mock.Call
}

func (_m AdminServiceServer_ListWorkflows) Return(_a0 *admin.WorkflowList, _a1 error) *AdminServiceServer_ListWorkflows {
	return &AdminServiceServer_ListWorkflows{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnListWorkflows(_a0 context.Context, _a1 *admin.ResourceListRequest) *AdminServiceServer_ListWorkflows {
	c_call := _m.On("ListWorkflows", _a0, _a1)
	return &AdminServiceServer_ListWorkflows{Call: c_call}
}

func (_m *AdminServiceServer) OnListWorkflowsMatch(matchers ...interface{}) *AdminServiceServer_ListWorkflows {
	c_call := _m.On("ListWorkflows", matchers...)
	return &AdminServiceServer_ListWorkflows{Call: c_call}
}

// ListWorkflows provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) ListWorkflows(_a0 context.Context, _a1 *admin.ResourceListRequest) (*admin.WorkflowList, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.WorkflowList
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ResourceListRequest) *admin.WorkflowList); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.WorkflowList)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.ResourceListRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_RecoverExecution struct {
	*mock.Call
}

func (_m AdminServiceServer_RecoverExecution) Return(_a0 *admin.ExecutionCreateResponse, _a1 error) *AdminServiceServer_RecoverExecution {
	return &AdminServiceServer_RecoverExecution{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnRecoverExecution(_a0 context.Context, _a1 *admin.ExecutionRecoverRequest) *AdminServiceServer_RecoverExecution {
	c_call := _m.On("RecoverExecution", _a0, _a1)
	return &AdminServiceServer_RecoverExecution{Call: c_call}
}

func (_m *AdminServiceServer) OnRecoverExecutionMatch(matchers ...interface{}) *AdminServiceServer_RecoverExecution {
	c_call := _m.On("RecoverExecution", matchers...)
	return &AdminServiceServer_RecoverExecution{Call: c_call}
}

// RecoverExecution provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) RecoverExecution(_a0 context.Context, _a1 *admin.ExecutionRecoverRequest) (*admin.ExecutionCreateResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.ExecutionCreateResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ExecutionRecoverRequest) *admin.ExecutionCreateResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.ExecutionCreateResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.ExecutionRecoverRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_RegisterProject struct {
	*mock.Call
}

func (_m AdminServiceServer_RegisterProject) Return(_a0 *admin.ProjectRegisterResponse, _a1 error) *AdminServiceServer_RegisterProject {
	return &AdminServiceServer_RegisterProject{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnRegisterProject(_a0 context.Context, _a1 *admin.ProjectRegisterRequest) *AdminServiceServer_RegisterProject {
	c_call := _m.On("RegisterProject", _a0, _a1)
	return &AdminServiceServer_RegisterProject{Call: c_call}
}

func (_m *AdminServiceServer) OnRegisterProjectMatch(matchers ...interface{}) *AdminServiceServer_RegisterProject {
	c_call := _m.On("RegisterProject", matchers...)
	return &AdminServiceServer_RegisterProject{Call: c_call}
}

// RegisterProject provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) RegisterProject(_a0 context.Context, _a1 *admin.ProjectRegisterRequest) (*admin.ProjectRegisterResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.ProjectRegisterResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ProjectRegisterRequest) *admin.ProjectRegisterResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.ProjectRegisterResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.ProjectRegisterRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_RelaunchExecution struct {
	*mock.Call
}

func (_m AdminServiceServer_RelaunchExecution) Return(_a0 *admin.ExecutionCreateResponse, _a1 error) *AdminServiceServer_RelaunchExecution {
	return &AdminServiceServer_RelaunchExecution{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnRelaunchExecution(_a0 context.Context, _a1 *admin.ExecutionRelaunchRequest) *AdminServiceServer_RelaunchExecution {
	c_call := _m.On("RelaunchExecution", _a0, _a1)
	return &AdminServiceServer_RelaunchExecution{Call: c_call}
}

func (_m *AdminServiceServer) OnRelaunchExecutionMatch(matchers ...interface{}) *AdminServiceServer_RelaunchExecution {
	c_call := _m.On("RelaunchExecution", matchers...)
	return &AdminServiceServer_RelaunchExecution{Call: c_call}
}

// RelaunchExecution provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) RelaunchExecution(_a0 context.Context, _a1 *admin.ExecutionRelaunchRequest) (*admin.ExecutionCreateResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.ExecutionCreateResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ExecutionRelaunchRequest) *admin.ExecutionCreateResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.ExecutionCreateResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.ExecutionRelaunchRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_TerminateExecution struct {
	*mock.Call
}

func (_m AdminServiceServer_TerminateExecution) Return(_a0 *admin.ExecutionTerminateResponse, _a1 error) *AdminServiceServer_TerminateExecution {
	return &AdminServiceServer_TerminateExecution{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnTerminateExecution(_a0 context.Context, _a1 *admin.ExecutionTerminateRequest) *AdminServiceServer_TerminateExecution {
	c_call := _m.On("TerminateExecution", _a0, _a1)
	return &AdminServiceServer_TerminateExecution{Call: c_call}
}

func (_m *AdminServiceServer) OnTerminateExecutionMatch(matchers ...interface{}) *AdminServiceServer_TerminateExecution {
	c_call := _m.On("TerminateExecution", matchers...)
	return &AdminServiceServer_TerminateExecution{Call: c_call}
}

// TerminateExecution provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) TerminateExecution(_a0 context.Context, _a1 *admin.ExecutionTerminateRequest) (*admin.ExecutionTerminateResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.ExecutionTerminateResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ExecutionTerminateRequest) *admin.ExecutionTerminateResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.ExecutionTerminateResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.ExecutionTerminateRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_UpdateExecution struct {
	*mock.Call
}

func (_m AdminServiceServer_UpdateExecution) Return(_a0 *admin.ExecutionUpdateResponse, _a1 error) *AdminServiceServer_UpdateExecution {
	return &AdminServiceServer_UpdateExecution{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnUpdateExecution(_a0 context.Context, _a1 *admin.ExecutionUpdateRequest) *AdminServiceServer_UpdateExecution {
	c_call := _m.On("UpdateExecution", _a0, _a1)
	return &AdminServiceServer_UpdateExecution{Call: c_call}
}

func (_m *AdminServiceServer) OnUpdateExecutionMatch(matchers ...interface{}) *AdminServiceServer_UpdateExecution {
	c_call := _m.On("UpdateExecution", matchers...)
	return &AdminServiceServer_UpdateExecution{Call: c_call}
}

// UpdateExecution provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) UpdateExecution(_a0 context.Context, _a1 *admin.ExecutionUpdateRequest) (*admin.ExecutionUpdateResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.ExecutionUpdateResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ExecutionUpdateRequest) *admin.ExecutionUpdateResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.ExecutionUpdateResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.ExecutionUpdateRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_UpdateLaunchPlan struct {
	*mock.Call
}

func (_m AdminServiceServer_UpdateLaunchPlan) Return(_a0 *admin.LaunchPlanUpdateResponse, _a1 error) *AdminServiceServer_UpdateLaunchPlan {
	return &AdminServiceServer_UpdateLaunchPlan{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnUpdateLaunchPlan(_a0 context.Context, _a1 *admin.LaunchPlanUpdateRequest) *AdminServiceServer_UpdateLaunchPlan {
	c_call := _m.On("UpdateLaunchPlan", _a0, _a1)
	return &AdminServiceServer_UpdateLaunchPlan{Call: c_call}
}

func (_m *AdminServiceServer) OnUpdateLaunchPlanMatch(matchers ...interface{}) *AdminServiceServer_UpdateLaunchPlan {
	c_call := _m.On("UpdateLaunchPlan", matchers...)
	return &AdminServiceServer_UpdateLaunchPlan{Call: c_call}
}

// UpdateLaunchPlan provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) UpdateLaunchPlan(_a0 context.Context, _a1 *admin.LaunchPlanUpdateRequest) (*admin.LaunchPlanUpdateResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.LaunchPlanUpdateResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.LaunchPlanUpdateRequest) *admin.LaunchPlanUpdateResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.LaunchPlanUpdateResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.LaunchPlanUpdateRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_UpdateNamedEntity struct {
	*mock.Call
}

func (_m AdminServiceServer_UpdateNamedEntity) Return(_a0 *admin.NamedEntityUpdateResponse, _a1 error) *AdminServiceServer_UpdateNamedEntity {
	return &AdminServiceServer_UpdateNamedEntity{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnUpdateNamedEntity(_a0 context.Context, _a1 *admin.NamedEntityUpdateRequest) *AdminServiceServer_UpdateNamedEntity {
	c_call := _m.On("UpdateNamedEntity", _a0, _a1)
	return &AdminServiceServer_UpdateNamedEntity{Call: c_call}
}

func (_m *AdminServiceServer) OnUpdateNamedEntityMatch(matchers ...interface{}) *AdminServiceServer_UpdateNamedEntity {
	c_call := _m.On("UpdateNamedEntity", matchers...)
	return &AdminServiceServer_UpdateNamedEntity{Call: c_call}
}

// UpdateNamedEntity provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) UpdateNamedEntity(_a0 context.Context, _a1 *admin.NamedEntityUpdateRequest) (*admin.NamedEntityUpdateResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.NamedEntityUpdateResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.NamedEntityUpdateRequest) *admin.NamedEntityUpdateResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.NamedEntityUpdateResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.NamedEntityUpdateRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_UpdateProject struct {
	*mock.Call
}

func (_m AdminServiceServer_UpdateProject) Return(_a0 *admin.ProjectUpdateResponse, _a1 error) *AdminServiceServer_UpdateProject {
	return &AdminServiceServer_UpdateProject{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnUpdateProject(_a0 context.Context, _a1 *admin.Project) *AdminServiceServer_UpdateProject {
	c_call := _m.On("UpdateProject", _a0, _a1)
	return &AdminServiceServer_UpdateProject{Call: c_call}
}

func (_m *AdminServiceServer) OnUpdateProjectMatch(matchers ...interface{}) *AdminServiceServer_UpdateProject {
	c_call := _m.On("UpdateProject", matchers...)
	return &AdminServiceServer_UpdateProject{Call: c_call}
}

// UpdateProject provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) UpdateProject(_a0 context.Context, _a1 *admin.Project) (*admin.ProjectUpdateResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.ProjectUpdateResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.Project) *admin.ProjectUpdateResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.ProjectUpdateResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.Project) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_UpdateProjectAttributes struct {
	*mock.Call
}

func (_m AdminServiceServer_UpdateProjectAttributes) Return(_a0 *admin.ProjectAttributesUpdateResponse, _a1 error) *AdminServiceServer_UpdateProjectAttributes {
	return &AdminServiceServer_UpdateProjectAttributes{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnUpdateProjectAttributes(_a0 context.Context, _a1 *admin.ProjectAttributesUpdateRequest) *AdminServiceServer_UpdateProjectAttributes {
	c_call := _m.On("UpdateProjectAttributes", _a0, _a1)
	return &AdminServiceServer_UpdateProjectAttributes{Call: c_call}
}

func (_m *AdminServiceServer) OnUpdateProjectAttributesMatch(matchers ...interface{}) *AdminServiceServer_UpdateProjectAttributes {
	c_call := _m.On("UpdateProjectAttributes", matchers...)
	return &AdminServiceServer_UpdateProjectAttributes{Call: c_call}
}

// UpdateProjectAttributes provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) UpdateProjectAttributes(_a0 context.Context, _a1 *admin.ProjectAttributesUpdateRequest) (*admin.ProjectAttributesUpdateResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.ProjectAttributesUpdateResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ProjectAttributesUpdateRequest) *admin.ProjectAttributesUpdateResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.ProjectAttributesUpdateResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.ProjectAttributesUpdateRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_UpdateProjectDomainAttributes struct {
	*mock.Call
}

func (_m AdminServiceServer_UpdateProjectDomainAttributes) Return(_a0 *admin.ProjectDomainAttributesUpdateResponse, _a1 error) *AdminServiceServer_UpdateProjectDomainAttributes {
	return &AdminServiceServer_UpdateProjectDomainAttributes{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnUpdateProjectDomainAttributes(_a0 context.Context, _a1 *admin.ProjectDomainAttributesUpdateRequest) *AdminServiceServer_UpdateProjectDomainAttributes {
	c_call := _m.On("UpdateProjectDomainAttributes", _a0, _a1)
	return &AdminServiceServer_UpdateProjectDomainAttributes{Call: c_call}
}

func (_m *AdminServiceServer) OnUpdateProjectDomainAttributesMatch(matchers ...interface{}) *AdminServiceServer_UpdateProjectDomainAttributes {
	c_call := _m.On("UpdateProjectDomainAttributes", matchers...)
	return &AdminServiceServer_UpdateProjectDomainAttributes{Call: c_call}
}

// UpdateProjectDomainAttributes provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) UpdateProjectDomainAttributes(_a0 context.Context, _a1 *admin.ProjectDomainAttributesUpdateRequest) (*admin.ProjectDomainAttributesUpdateResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.ProjectDomainAttributesUpdateResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ProjectDomainAttributesUpdateRequest) *admin.ProjectDomainAttributesUpdateResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.ProjectDomainAttributesUpdateResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.ProjectDomainAttributesUpdateRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceServer_UpdateWorkflowAttributes struct {
	*mock.Call
}

func (_m AdminServiceServer_UpdateWorkflowAttributes) Return(_a0 *admin.WorkflowAttributesUpdateResponse, _a1 error) *AdminServiceServer_UpdateWorkflowAttributes {
	return &AdminServiceServer_UpdateWorkflowAttributes{Call: _m.Call.Return(_a0, _a1)}
}

func (_m *AdminServiceServer) OnUpdateWorkflowAttributes(_a0 context.Context, _a1 *admin.WorkflowAttributesUpdateRequest) *AdminServiceServer_UpdateWorkflowAttributes {
	c_call := _m.On("UpdateWorkflowAttributes", _a0, _a1)
	return &AdminServiceServer_UpdateWorkflowAttributes{Call: c_call}
}

func (_m *AdminServiceServer) OnUpdateWorkflowAttributesMatch(matchers ...interface{}) *AdminServiceServer_UpdateWorkflowAttributes {
	c_call := _m.On("UpdateWorkflowAttributes", matchers...)
	return &AdminServiceServer_UpdateWorkflowAttributes{Call: c_call}
}

// UpdateWorkflowAttributes provides a mock function with given fields: _a0, _a1
func (_m *AdminServiceServer) UpdateWorkflowAttributes(_a0 context.Context, _a1 *admin.WorkflowAttributesUpdateRequest) (*admin.WorkflowAttributesUpdateResponse, error) {
	ret := _m.Called(_a0, _a1)

	var r0 *admin.WorkflowAttributesUpdateResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.WorkflowAttributesUpdateRequest) *admin.WorkflowAttributesUpdateResponse); ok {
		r0 = rf(_a0, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*admin.WorkflowAttributesUpdateResponse)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *admin.WorkflowAttributesUpdateRequest) error); ok {
		r1 = rf(_a0, _a1)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}
