AdminServiceClient.go

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

package mocks

import (
	context "context"

	admin "github.com/lyft/flyteidl/gen/pb-go/flyteidl/admin"

	grpc "google.golang.org/grpc"

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

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

type AdminServiceClient_CreateExecution struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnCreateExecution(ctx context.Context, in *admin.ExecutionCreateRequest, opts ...grpc.CallOption) *AdminServiceClient_CreateExecution {
	c := _m.On("CreateExecution", ctx, in, opts)
	return &AdminServiceClient_CreateExecution{Call: c}
}

func (_m *AdminServiceClient) OnCreateExecutionMatch(matchers ...interface{}) *AdminServiceClient_CreateExecution {
	c := _m.On("CreateExecution", matchers...)
	return &AdminServiceClient_CreateExecution{Call: c}
}

// CreateExecution provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) CreateExecution(ctx context.Context, in *admin.ExecutionCreateRequest, opts ...grpc.CallOption) (*admin.ExecutionCreateResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.ExecutionCreateResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ExecutionCreateRequest, ...grpc.CallOption) *admin.ExecutionCreateResponse); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_CreateLaunchPlan struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnCreateLaunchPlan(ctx context.Context, in *admin.LaunchPlanCreateRequest, opts ...grpc.CallOption) *AdminServiceClient_CreateLaunchPlan {
	c := _m.On("CreateLaunchPlan", ctx, in, opts)
	return &AdminServiceClient_CreateLaunchPlan{Call: c}
}

func (_m *AdminServiceClient) OnCreateLaunchPlanMatch(matchers ...interface{}) *AdminServiceClient_CreateLaunchPlan {
	c := _m.On("CreateLaunchPlan", matchers...)
	return &AdminServiceClient_CreateLaunchPlan{Call: c}
}

// CreateLaunchPlan provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) CreateLaunchPlan(ctx context.Context, in *admin.LaunchPlanCreateRequest, opts ...grpc.CallOption) (*admin.LaunchPlanCreateResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.LaunchPlanCreateResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.LaunchPlanCreateRequest, ...grpc.CallOption) *admin.LaunchPlanCreateResponse); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_CreateNodeEvent struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnCreateNodeEvent(ctx context.Context, in *admin.NodeExecutionEventRequest, opts ...grpc.CallOption) *AdminServiceClient_CreateNodeEvent {
	c := _m.On("CreateNodeEvent", ctx, in, opts)
	return &AdminServiceClient_CreateNodeEvent{Call: c}
}

func (_m *AdminServiceClient) OnCreateNodeEventMatch(matchers ...interface{}) *AdminServiceClient_CreateNodeEvent {
	c := _m.On("CreateNodeEvent", matchers...)
	return &AdminServiceClient_CreateNodeEvent{Call: c}
}

// CreateNodeEvent provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) CreateNodeEvent(ctx context.Context, in *admin.NodeExecutionEventRequest, opts ...grpc.CallOption) (*admin.NodeExecutionEventResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.NodeExecutionEventResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.NodeExecutionEventRequest, ...grpc.CallOption) *admin.NodeExecutionEventResponse); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_CreateTask struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnCreateTask(ctx context.Context, in *admin.TaskCreateRequest, opts ...grpc.CallOption) *AdminServiceClient_CreateTask {
	c := _m.On("CreateTask", ctx, in, opts)
	return &AdminServiceClient_CreateTask{Call: c}
}

func (_m *AdminServiceClient) OnCreateTaskMatch(matchers ...interface{}) *AdminServiceClient_CreateTask {
	c := _m.On("CreateTask", matchers...)
	return &AdminServiceClient_CreateTask{Call: c}
}

// CreateTask provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) CreateTask(ctx context.Context, in *admin.TaskCreateRequest, opts ...grpc.CallOption) (*admin.TaskCreateResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.TaskCreateResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.TaskCreateRequest, ...grpc.CallOption) *admin.TaskCreateResponse); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_CreateTaskEvent struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnCreateTaskEvent(ctx context.Context, in *admin.TaskExecutionEventRequest, opts ...grpc.CallOption) *AdminServiceClient_CreateTaskEvent {
	c := _m.On("CreateTaskEvent", ctx, in, opts)
	return &AdminServiceClient_CreateTaskEvent{Call: c}
}

func (_m *AdminServiceClient) OnCreateTaskEventMatch(matchers ...interface{}) *AdminServiceClient_CreateTaskEvent {
	c := _m.On("CreateTaskEvent", matchers...)
	return &AdminServiceClient_CreateTaskEvent{Call: c}
}

// CreateTaskEvent provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) CreateTaskEvent(ctx context.Context, in *admin.TaskExecutionEventRequest, opts ...grpc.CallOption) (*admin.TaskExecutionEventResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.TaskExecutionEventResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.TaskExecutionEventRequest, ...grpc.CallOption) *admin.TaskExecutionEventResponse); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_CreateWorkflow struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnCreateWorkflow(ctx context.Context, in *admin.WorkflowCreateRequest, opts ...grpc.CallOption) *AdminServiceClient_CreateWorkflow {
	c := _m.On("CreateWorkflow", ctx, in, opts)
	return &AdminServiceClient_CreateWorkflow{Call: c}
}

func (_m *AdminServiceClient) OnCreateWorkflowMatch(matchers ...interface{}) *AdminServiceClient_CreateWorkflow {
	c := _m.On("CreateWorkflow", matchers...)
	return &AdminServiceClient_CreateWorkflow{Call: c}
}

// CreateWorkflow provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) CreateWorkflow(ctx context.Context, in *admin.WorkflowCreateRequest, opts ...grpc.CallOption) (*admin.WorkflowCreateResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.WorkflowCreateResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.WorkflowCreateRequest, ...grpc.CallOption) *admin.WorkflowCreateResponse); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_CreateWorkflowEvent struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnCreateWorkflowEvent(ctx context.Context, in *admin.WorkflowExecutionEventRequest, opts ...grpc.CallOption) *AdminServiceClient_CreateWorkflowEvent {
	c := _m.On("CreateWorkflowEvent", ctx, in, opts)
	return &AdminServiceClient_CreateWorkflowEvent{Call: c}
}

func (_m *AdminServiceClient) OnCreateWorkflowEventMatch(matchers ...interface{}) *AdminServiceClient_CreateWorkflowEvent {
	c := _m.On("CreateWorkflowEvent", matchers...)
	return &AdminServiceClient_CreateWorkflowEvent{Call: c}
}

// CreateWorkflowEvent provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) CreateWorkflowEvent(ctx context.Context, in *admin.WorkflowExecutionEventRequest, opts ...grpc.CallOption) (*admin.WorkflowExecutionEventResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.WorkflowExecutionEventResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.WorkflowExecutionEventRequest, ...grpc.CallOption) *admin.WorkflowExecutionEventResponse); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_DeleteProjectDomainAttributes struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnDeleteProjectDomainAttributes(ctx context.Context, in *admin.ProjectDomainAttributesDeleteRequest, opts ...grpc.CallOption) *AdminServiceClient_DeleteProjectDomainAttributes {
	c := _m.On("DeleteProjectDomainAttributes", ctx, in, opts)
	return &AdminServiceClient_DeleteProjectDomainAttributes{Call: c}
}

func (_m *AdminServiceClient) OnDeleteProjectDomainAttributesMatch(matchers ...interface{}) *AdminServiceClient_DeleteProjectDomainAttributes {
	c := _m.On("DeleteProjectDomainAttributes", matchers...)
	return &AdminServiceClient_DeleteProjectDomainAttributes{Call: c}
}

// DeleteProjectDomainAttributes provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) DeleteProjectDomainAttributes(ctx context.Context, in *admin.ProjectDomainAttributesDeleteRequest, opts ...grpc.CallOption) (*admin.ProjectDomainAttributesDeleteResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.ProjectDomainAttributesDeleteResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ProjectDomainAttributesDeleteRequest, ...grpc.CallOption) *admin.ProjectDomainAttributesDeleteResponse); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_DeleteWorkflowAttributes struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnDeleteWorkflowAttributes(ctx context.Context, in *admin.WorkflowAttributesDeleteRequest, opts ...grpc.CallOption) *AdminServiceClient_DeleteWorkflowAttributes {
	c := _m.On("DeleteWorkflowAttributes", ctx, in, opts)
	return &AdminServiceClient_DeleteWorkflowAttributes{Call: c}
}

func (_m *AdminServiceClient) OnDeleteWorkflowAttributesMatch(matchers ...interface{}) *AdminServiceClient_DeleteWorkflowAttributes {
	c := _m.On("DeleteWorkflowAttributes", matchers...)
	return &AdminServiceClient_DeleteWorkflowAttributes{Call: c}
}

// DeleteWorkflowAttributes provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) DeleteWorkflowAttributes(ctx context.Context, in *admin.WorkflowAttributesDeleteRequest, opts ...grpc.CallOption) (*admin.WorkflowAttributesDeleteResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.WorkflowAttributesDeleteResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.WorkflowAttributesDeleteRequest, ...grpc.CallOption) *admin.WorkflowAttributesDeleteResponse); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_GetActiveLaunchPlan struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnGetActiveLaunchPlan(ctx context.Context, in *admin.ActiveLaunchPlanRequest, opts ...grpc.CallOption) *AdminServiceClient_GetActiveLaunchPlan {
	c := _m.On("GetActiveLaunchPlan", ctx, in, opts)
	return &AdminServiceClient_GetActiveLaunchPlan{Call: c}
}

func (_m *AdminServiceClient) OnGetActiveLaunchPlanMatch(matchers ...interface{}) *AdminServiceClient_GetActiveLaunchPlan {
	c := _m.On("GetActiveLaunchPlan", matchers...)
	return &AdminServiceClient_GetActiveLaunchPlan{Call: c}
}

// GetActiveLaunchPlan provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) GetActiveLaunchPlan(ctx context.Context, in *admin.ActiveLaunchPlanRequest, opts ...grpc.CallOption) (*admin.LaunchPlan, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.LaunchPlan
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ActiveLaunchPlanRequest, ...grpc.CallOption) *admin.LaunchPlan); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_GetExecution struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnGetExecution(ctx context.Context, in *admin.WorkflowExecutionGetRequest, opts ...grpc.CallOption) *AdminServiceClient_GetExecution {
	c := _m.On("GetExecution", ctx, in, opts)
	return &AdminServiceClient_GetExecution{Call: c}
}

func (_m *AdminServiceClient) OnGetExecutionMatch(matchers ...interface{}) *AdminServiceClient_GetExecution {
	c := _m.On("GetExecution", matchers...)
	return &AdminServiceClient_GetExecution{Call: c}
}

// GetExecution provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) GetExecution(ctx context.Context, in *admin.WorkflowExecutionGetRequest, opts ...grpc.CallOption) (*admin.Execution, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.Execution
	if rf, ok := ret.Get(0).(func(context.Context, *admin.WorkflowExecutionGetRequest, ...grpc.CallOption) *admin.Execution); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_GetExecutionData struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnGetExecutionData(ctx context.Context, in *admin.WorkflowExecutionGetDataRequest, opts ...grpc.CallOption) *AdminServiceClient_GetExecutionData {
	c := _m.On("GetExecutionData", ctx, in, opts)
	return &AdminServiceClient_GetExecutionData{Call: c}
}

func (_m *AdminServiceClient) OnGetExecutionDataMatch(matchers ...interface{}) *AdminServiceClient_GetExecutionData {
	c := _m.On("GetExecutionData", matchers...)
	return &AdminServiceClient_GetExecutionData{Call: c}
}

// GetExecutionData provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) GetExecutionData(ctx context.Context, in *admin.WorkflowExecutionGetDataRequest, opts ...grpc.CallOption) (*admin.WorkflowExecutionGetDataResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.WorkflowExecutionGetDataResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.WorkflowExecutionGetDataRequest, ...grpc.CallOption) *admin.WorkflowExecutionGetDataResponse); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_GetLaunchPlan struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnGetLaunchPlan(ctx context.Context, in *admin.ObjectGetRequest, opts ...grpc.CallOption) *AdminServiceClient_GetLaunchPlan {
	c := _m.On("GetLaunchPlan", ctx, in, opts)
	return &AdminServiceClient_GetLaunchPlan{Call: c}
}

func (_m *AdminServiceClient) OnGetLaunchPlanMatch(matchers ...interface{}) *AdminServiceClient_GetLaunchPlan {
	c := _m.On("GetLaunchPlan", matchers...)
	return &AdminServiceClient_GetLaunchPlan{Call: c}
}

// GetLaunchPlan provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) GetLaunchPlan(ctx context.Context, in *admin.ObjectGetRequest, opts ...grpc.CallOption) (*admin.LaunchPlan, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.LaunchPlan
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ObjectGetRequest, ...grpc.CallOption) *admin.LaunchPlan); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_GetNamedEntity struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnGetNamedEntity(ctx context.Context, in *admin.NamedEntityGetRequest, opts ...grpc.CallOption) *AdminServiceClient_GetNamedEntity {
	c := _m.On("GetNamedEntity", ctx, in, opts)
	return &AdminServiceClient_GetNamedEntity{Call: c}
}

func (_m *AdminServiceClient) OnGetNamedEntityMatch(matchers ...interface{}) *AdminServiceClient_GetNamedEntity {
	c := _m.On("GetNamedEntity", matchers...)
	return &AdminServiceClient_GetNamedEntity{Call: c}
}

// GetNamedEntity provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) GetNamedEntity(ctx context.Context, in *admin.NamedEntityGetRequest, opts ...grpc.CallOption) (*admin.NamedEntity, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.NamedEntity
	if rf, ok := ret.Get(0).(func(context.Context, *admin.NamedEntityGetRequest, ...grpc.CallOption) *admin.NamedEntity); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_GetNodeExecution struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnGetNodeExecution(ctx context.Context, in *admin.NodeExecutionGetRequest, opts ...grpc.CallOption) *AdminServiceClient_GetNodeExecution {
	c := _m.On("GetNodeExecution", ctx, in, opts)
	return &AdminServiceClient_GetNodeExecution{Call: c}
}

func (_m *AdminServiceClient) OnGetNodeExecutionMatch(matchers ...interface{}) *AdminServiceClient_GetNodeExecution {
	c := _m.On("GetNodeExecution", matchers...)
	return &AdminServiceClient_GetNodeExecution{Call: c}
}

// GetNodeExecution provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) GetNodeExecution(ctx context.Context, in *admin.NodeExecutionGetRequest, opts ...grpc.CallOption) (*admin.NodeExecution, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.NodeExecution
	if rf, ok := ret.Get(0).(func(context.Context, *admin.NodeExecutionGetRequest, ...grpc.CallOption) *admin.NodeExecution); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_GetNodeExecutionData struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnGetNodeExecutionData(ctx context.Context, in *admin.NodeExecutionGetDataRequest, opts ...grpc.CallOption) *AdminServiceClient_GetNodeExecutionData {
	c := _m.On("GetNodeExecutionData", ctx, in, opts)
	return &AdminServiceClient_GetNodeExecutionData{Call: c}
}

func (_m *AdminServiceClient) OnGetNodeExecutionDataMatch(matchers ...interface{}) *AdminServiceClient_GetNodeExecutionData {
	c := _m.On("GetNodeExecutionData", matchers...)
	return &AdminServiceClient_GetNodeExecutionData{Call: c}
}

// GetNodeExecutionData provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) GetNodeExecutionData(ctx context.Context, in *admin.NodeExecutionGetDataRequest, opts ...grpc.CallOption) (*admin.NodeExecutionGetDataResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.NodeExecutionGetDataResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.NodeExecutionGetDataRequest, ...grpc.CallOption) *admin.NodeExecutionGetDataResponse); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_GetProjectDomainAttributes struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnGetProjectDomainAttributes(ctx context.Context, in *admin.ProjectDomainAttributesGetRequest, opts ...grpc.CallOption) *AdminServiceClient_GetProjectDomainAttributes {
	c := _m.On("GetProjectDomainAttributes", ctx, in, opts)
	return &AdminServiceClient_GetProjectDomainAttributes{Call: c}
}

func (_m *AdminServiceClient) OnGetProjectDomainAttributesMatch(matchers ...interface{}) *AdminServiceClient_GetProjectDomainAttributes {
	c := _m.On("GetProjectDomainAttributes", matchers...)
	return &AdminServiceClient_GetProjectDomainAttributes{Call: c}
}

// GetProjectDomainAttributes provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) GetProjectDomainAttributes(ctx context.Context, in *admin.ProjectDomainAttributesGetRequest, opts ...grpc.CallOption) (*admin.ProjectDomainAttributesGetResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.ProjectDomainAttributesGetResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ProjectDomainAttributesGetRequest, ...grpc.CallOption) *admin.ProjectDomainAttributesGetResponse); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_GetTask struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnGetTask(ctx context.Context, in *admin.ObjectGetRequest, opts ...grpc.CallOption) *AdminServiceClient_GetTask {
	c := _m.On("GetTask", ctx, in, opts)
	return &AdminServiceClient_GetTask{Call: c}
}

func (_m *AdminServiceClient) OnGetTaskMatch(matchers ...interface{}) *AdminServiceClient_GetTask {
	c := _m.On("GetTask", matchers...)
	return &AdminServiceClient_GetTask{Call: c}
}

// GetTask provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) GetTask(ctx context.Context, in *admin.ObjectGetRequest, opts ...grpc.CallOption) (*admin.Task, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.Task
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ObjectGetRequest, ...grpc.CallOption) *admin.Task); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_GetTaskExecution struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnGetTaskExecution(ctx context.Context, in *admin.TaskExecutionGetRequest, opts ...grpc.CallOption) *AdminServiceClient_GetTaskExecution {
	c := _m.On("GetTaskExecution", ctx, in, opts)
	return &AdminServiceClient_GetTaskExecution{Call: c}
}

func (_m *AdminServiceClient) OnGetTaskExecutionMatch(matchers ...interface{}) *AdminServiceClient_GetTaskExecution {
	c := _m.On("GetTaskExecution", matchers...)
	return &AdminServiceClient_GetTaskExecution{Call: c}
}

// GetTaskExecution provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) GetTaskExecution(ctx context.Context, in *admin.TaskExecutionGetRequest, opts ...grpc.CallOption) (*admin.TaskExecution, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.TaskExecution
	if rf, ok := ret.Get(0).(func(context.Context, *admin.TaskExecutionGetRequest, ...grpc.CallOption) *admin.TaskExecution); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_GetTaskExecutionData struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnGetTaskExecutionData(ctx context.Context, in *admin.TaskExecutionGetDataRequest, opts ...grpc.CallOption) *AdminServiceClient_GetTaskExecutionData {
	c := _m.On("GetTaskExecutionData", ctx, in, opts)
	return &AdminServiceClient_GetTaskExecutionData{Call: c}
}

func (_m *AdminServiceClient) OnGetTaskExecutionDataMatch(matchers ...interface{}) *AdminServiceClient_GetTaskExecutionData {
	c := _m.On("GetTaskExecutionData", matchers...)
	return &AdminServiceClient_GetTaskExecutionData{Call: c}
}

// GetTaskExecutionData provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) GetTaskExecutionData(ctx context.Context, in *admin.TaskExecutionGetDataRequest, opts ...grpc.CallOption) (*admin.TaskExecutionGetDataResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.TaskExecutionGetDataResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.TaskExecutionGetDataRequest, ...grpc.CallOption) *admin.TaskExecutionGetDataResponse); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_GetWorkflow struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnGetWorkflow(ctx context.Context, in *admin.ObjectGetRequest, opts ...grpc.CallOption) *AdminServiceClient_GetWorkflow {
	c := _m.On("GetWorkflow", ctx, in, opts)
	return &AdminServiceClient_GetWorkflow{Call: c}
}

func (_m *AdminServiceClient) OnGetWorkflowMatch(matchers ...interface{}) *AdminServiceClient_GetWorkflow {
	c := _m.On("GetWorkflow", matchers...)
	return &AdminServiceClient_GetWorkflow{Call: c}
}

// GetWorkflow provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) GetWorkflow(ctx context.Context, in *admin.ObjectGetRequest, opts ...grpc.CallOption) (*admin.Workflow, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.Workflow
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ObjectGetRequest, ...grpc.CallOption) *admin.Workflow); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_GetWorkflowAttributes struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnGetWorkflowAttributes(ctx context.Context, in *admin.WorkflowAttributesGetRequest, opts ...grpc.CallOption) *AdminServiceClient_GetWorkflowAttributes {
	c := _m.On("GetWorkflowAttributes", ctx, in, opts)
	return &AdminServiceClient_GetWorkflowAttributes{Call: c}
}

func (_m *AdminServiceClient) OnGetWorkflowAttributesMatch(matchers ...interface{}) *AdminServiceClient_GetWorkflowAttributes {
	c := _m.On("GetWorkflowAttributes", matchers...)
	return &AdminServiceClient_GetWorkflowAttributes{Call: c}
}

// GetWorkflowAttributes provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) GetWorkflowAttributes(ctx context.Context, in *admin.WorkflowAttributesGetRequest, opts ...grpc.CallOption) (*admin.WorkflowAttributesGetResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.WorkflowAttributesGetResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.WorkflowAttributesGetRequest, ...grpc.CallOption) *admin.WorkflowAttributesGetResponse); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_ListActiveLaunchPlans struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnListActiveLaunchPlans(ctx context.Context, in *admin.ActiveLaunchPlanListRequest, opts ...grpc.CallOption) *AdminServiceClient_ListActiveLaunchPlans {
	c := _m.On("ListActiveLaunchPlans", ctx, in, opts)
	return &AdminServiceClient_ListActiveLaunchPlans{Call: c}
}

func (_m *AdminServiceClient) OnListActiveLaunchPlansMatch(matchers ...interface{}) *AdminServiceClient_ListActiveLaunchPlans {
	c := _m.On("ListActiveLaunchPlans", matchers...)
	return &AdminServiceClient_ListActiveLaunchPlans{Call: c}
}

// ListActiveLaunchPlans provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) ListActiveLaunchPlans(ctx context.Context, in *admin.ActiveLaunchPlanListRequest, opts ...grpc.CallOption) (*admin.LaunchPlanList, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.LaunchPlanList
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ActiveLaunchPlanListRequest, ...grpc.CallOption) *admin.LaunchPlanList); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_ListExecutions struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnListExecutions(ctx context.Context, in *admin.ResourceListRequest, opts ...grpc.CallOption) *AdminServiceClient_ListExecutions {
	c := _m.On("ListExecutions", ctx, in, opts)
	return &AdminServiceClient_ListExecutions{Call: c}
}

func (_m *AdminServiceClient) OnListExecutionsMatch(matchers ...interface{}) *AdminServiceClient_ListExecutions {
	c := _m.On("ListExecutions", matchers...)
	return &AdminServiceClient_ListExecutions{Call: c}
}

// ListExecutions provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) ListExecutions(ctx context.Context, in *admin.ResourceListRequest, opts ...grpc.CallOption) (*admin.ExecutionList, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.ExecutionList
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ResourceListRequest, ...grpc.CallOption) *admin.ExecutionList); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_ListLaunchPlanIds struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnListLaunchPlanIds(ctx context.Context, in *admin.NamedEntityIdentifierListRequest, opts ...grpc.CallOption) *AdminServiceClient_ListLaunchPlanIds {
	c := _m.On("ListLaunchPlanIds", ctx, in, opts)
	return &AdminServiceClient_ListLaunchPlanIds{Call: c}
}

func (_m *AdminServiceClient) OnListLaunchPlanIdsMatch(matchers ...interface{}) *AdminServiceClient_ListLaunchPlanIds {
	c := _m.On("ListLaunchPlanIds", matchers...)
	return &AdminServiceClient_ListLaunchPlanIds{Call: c}
}

// ListLaunchPlanIds provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) ListLaunchPlanIds(ctx context.Context, in *admin.NamedEntityIdentifierListRequest, opts ...grpc.CallOption) (*admin.NamedEntityIdentifierList, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.NamedEntityIdentifierList
	if rf, ok := ret.Get(0).(func(context.Context, *admin.NamedEntityIdentifierListRequest, ...grpc.CallOption) *admin.NamedEntityIdentifierList); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_ListLaunchPlans struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnListLaunchPlans(ctx context.Context, in *admin.ResourceListRequest, opts ...grpc.CallOption) *AdminServiceClient_ListLaunchPlans {
	c := _m.On("ListLaunchPlans", ctx, in, opts)
	return &AdminServiceClient_ListLaunchPlans{Call: c}
}

func (_m *AdminServiceClient) OnListLaunchPlansMatch(matchers ...interface{}) *AdminServiceClient_ListLaunchPlans {
	c := _m.On("ListLaunchPlans", matchers...)
	return &AdminServiceClient_ListLaunchPlans{Call: c}
}

// ListLaunchPlans provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) ListLaunchPlans(ctx context.Context, in *admin.ResourceListRequest, opts ...grpc.CallOption) (*admin.LaunchPlanList, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.LaunchPlanList
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ResourceListRequest, ...grpc.CallOption) *admin.LaunchPlanList); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_ListNamedEntities struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnListNamedEntities(ctx context.Context, in *admin.NamedEntityListRequest, opts ...grpc.CallOption) *AdminServiceClient_ListNamedEntities {
	c := _m.On("ListNamedEntities", ctx, in, opts)
	return &AdminServiceClient_ListNamedEntities{Call: c}
}

func (_m *AdminServiceClient) OnListNamedEntitiesMatch(matchers ...interface{}) *AdminServiceClient_ListNamedEntities {
	c := _m.On("ListNamedEntities", matchers...)
	return &AdminServiceClient_ListNamedEntities{Call: c}
}

// ListNamedEntities provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) ListNamedEntities(ctx context.Context, in *admin.NamedEntityListRequest, opts ...grpc.CallOption) (*admin.NamedEntityList, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.NamedEntityList
	if rf, ok := ret.Get(0).(func(context.Context, *admin.NamedEntityListRequest, ...grpc.CallOption) *admin.NamedEntityList); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_ListNodeExecutions struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnListNodeExecutions(ctx context.Context, in *admin.NodeExecutionListRequest, opts ...grpc.CallOption) *AdminServiceClient_ListNodeExecutions {
	c := _m.On("ListNodeExecutions", ctx, in, opts)
	return &AdminServiceClient_ListNodeExecutions{Call: c}
}

func (_m *AdminServiceClient) OnListNodeExecutionsMatch(matchers ...interface{}) *AdminServiceClient_ListNodeExecutions {
	c := _m.On("ListNodeExecutions", matchers...)
	return &AdminServiceClient_ListNodeExecutions{Call: c}
}

// ListNodeExecutions provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) ListNodeExecutions(ctx context.Context, in *admin.NodeExecutionListRequest, opts ...grpc.CallOption) (*admin.NodeExecutionList, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.NodeExecutionList
	if rf, ok := ret.Get(0).(func(context.Context, *admin.NodeExecutionListRequest, ...grpc.CallOption) *admin.NodeExecutionList); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_ListNodeExecutionsForTask struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnListNodeExecutionsForTask(ctx context.Context, in *admin.NodeExecutionForTaskListRequest, opts ...grpc.CallOption) *AdminServiceClient_ListNodeExecutionsForTask {
	c := _m.On("ListNodeExecutionsForTask", ctx, in, opts)
	return &AdminServiceClient_ListNodeExecutionsForTask{Call: c}
}

func (_m *AdminServiceClient) OnListNodeExecutionsForTaskMatch(matchers ...interface{}) *AdminServiceClient_ListNodeExecutionsForTask {
	c := _m.On("ListNodeExecutionsForTask", matchers...)
	return &AdminServiceClient_ListNodeExecutionsForTask{Call: c}
}

// ListNodeExecutionsForTask provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) ListNodeExecutionsForTask(ctx context.Context, in *admin.NodeExecutionForTaskListRequest, opts ...grpc.CallOption) (*admin.NodeExecutionList, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.NodeExecutionList
	if rf, ok := ret.Get(0).(func(context.Context, *admin.NodeExecutionForTaskListRequest, ...grpc.CallOption) *admin.NodeExecutionList); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_ListProjects struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnListProjects(ctx context.Context, in *admin.ProjectListRequest, opts ...grpc.CallOption) *AdminServiceClient_ListProjects {
	c := _m.On("ListProjects", ctx, in, opts)
	return &AdminServiceClient_ListProjects{Call: c}
}

func (_m *AdminServiceClient) OnListProjectsMatch(matchers ...interface{}) *AdminServiceClient_ListProjects {
	c := _m.On("ListProjects", matchers...)
	return &AdminServiceClient_ListProjects{Call: c}
}

// ListProjects provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) ListProjects(ctx context.Context, in *admin.ProjectListRequest, opts ...grpc.CallOption) (*admin.Projects, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.Projects
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ProjectListRequest, ...grpc.CallOption) *admin.Projects); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_ListTaskExecutions struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnListTaskExecutions(ctx context.Context, in *admin.TaskExecutionListRequest, opts ...grpc.CallOption) *AdminServiceClient_ListTaskExecutions {
	c := _m.On("ListTaskExecutions", ctx, in, opts)
	return &AdminServiceClient_ListTaskExecutions{Call: c}
}

func (_m *AdminServiceClient) OnListTaskExecutionsMatch(matchers ...interface{}) *AdminServiceClient_ListTaskExecutions {
	c := _m.On("ListTaskExecutions", matchers...)
	return &AdminServiceClient_ListTaskExecutions{Call: c}
}

// ListTaskExecutions provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) ListTaskExecutions(ctx context.Context, in *admin.TaskExecutionListRequest, opts ...grpc.CallOption) (*admin.TaskExecutionList, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.TaskExecutionList
	if rf, ok := ret.Get(0).(func(context.Context, *admin.TaskExecutionListRequest, ...grpc.CallOption) *admin.TaskExecutionList); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_ListTaskIds struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnListTaskIds(ctx context.Context, in *admin.NamedEntityIdentifierListRequest, opts ...grpc.CallOption) *AdminServiceClient_ListTaskIds {
	c := _m.On("ListTaskIds", ctx, in, opts)
	return &AdminServiceClient_ListTaskIds{Call: c}
}

func (_m *AdminServiceClient) OnListTaskIdsMatch(matchers ...interface{}) *AdminServiceClient_ListTaskIds {
	c := _m.On("ListTaskIds", matchers...)
	return &AdminServiceClient_ListTaskIds{Call: c}
}

// ListTaskIds provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) ListTaskIds(ctx context.Context, in *admin.NamedEntityIdentifierListRequest, opts ...grpc.CallOption) (*admin.NamedEntityIdentifierList, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.NamedEntityIdentifierList
	if rf, ok := ret.Get(0).(func(context.Context, *admin.NamedEntityIdentifierListRequest, ...grpc.CallOption) *admin.NamedEntityIdentifierList); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_ListTasks struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnListTasks(ctx context.Context, in *admin.ResourceListRequest, opts ...grpc.CallOption) *AdminServiceClient_ListTasks {
	c := _m.On("ListTasks", ctx, in, opts)
	return &AdminServiceClient_ListTasks{Call: c}
}

func (_m *AdminServiceClient) OnListTasksMatch(matchers ...interface{}) *AdminServiceClient_ListTasks {
	c := _m.On("ListTasks", matchers...)
	return &AdminServiceClient_ListTasks{Call: c}
}

// ListTasks provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) ListTasks(ctx context.Context, in *admin.ResourceListRequest, opts ...grpc.CallOption) (*admin.TaskList, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.TaskList
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ResourceListRequest, ...grpc.CallOption) *admin.TaskList); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_ListWorkflowIds struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnListWorkflowIds(ctx context.Context, in *admin.NamedEntityIdentifierListRequest, opts ...grpc.CallOption) *AdminServiceClient_ListWorkflowIds {
	c := _m.On("ListWorkflowIds", ctx, in, opts)
	return &AdminServiceClient_ListWorkflowIds{Call: c}
}

func (_m *AdminServiceClient) OnListWorkflowIdsMatch(matchers ...interface{}) *AdminServiceClient_ListWorkflowIds {
	c := _m.On("ListWorkflowIds", matchers...)
	return &AdminServiceClient_ListWorkflowIds{Call: c}
}

// ListWorkflowIds provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) ListWorkflowIds(ctx context.Context, in *admin.NamedEntityIdentifierListRequest, opts ...grpc.CallOption) (*admin.NamedEntityIdentifierList, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.NamedEntityIdentifierList
	if rf, ok := ret.Get(0).(func(context.Context, *admin.NamedEntityIdentifierListRequest, ...grpc.CallOption) *admin.NamedEntityIdentifierList); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_ListWorkflows struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnListWorkflows(ctx context.Context, in *admin.ResourceListRequest, opts ...grpc.CallOption) *AdminServiceClient_ListWorkflows {
	c := _m.On("ListWorkflows", ctx, in, opts)
	return &AdminServiceClient_ListWorkflows{Call: c}
}

func (_m *AdminServiceClient) OnListWorkflowsMatch(matchers ...interface{}) *AdminServiceClient_ListWorkflows {
	c := _m.On("ListWorkflows", matchers...)
	return &AdminServiceClient_ListWorkflows{Call: c}
}

// ListWorkflows provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) ListWorkflows(ctx context.Context, in *admin.ResourceListRequest, opts ...grpc.CallOption) (*admin.WorkflowList, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.WorkflowList
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ResourceListRequest, ...grpc.CallOption) *admin.WorkflowList); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_RegisterProject struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnRegisterProject(ctx context.Context, in *admin.ProjectRegisterRequest, opts ...grpc.CallOption) *AdminServiceClient_RegisterProject {
	c := _m.On("RegisterProject", ctx, in, opts)
	return &AdminServiceClient_RegisterProject{Call: c}
}

func (_m *AdminServiceClient) OnRegisterProjectMatch(matchers ...interface{}) *AdminServiceClient_RegisterProject {
	c := _m.On("RegisterProject", matchers...)
	return &AdminServiceClient_RegisterProject{Call: c}
}

// RegisterProject provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) RegisterProject(ctx context.Context, in *admin.ProjectRegisterRequest, opts ...grpc.CallOption) (*admin.ProjectRegisterResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.ProjectRegisterResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ProjectRegisterRequest, ...grpc.CallOption) *admin.ProjectRegisterResponse); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_RelaunchExecution struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnRelaunchExecution(ctx context.Context, in *admin.ExecutionRelaunchRequest, opts ...grpc.CallOption) *AdminServiceClient_RelaunchExecution {
	c := _m.On("RelaunchExecution", ctx, in, opts)
	return &AdminServiceClient_RelaunchExecution{Call: c}
}

func (_m *AdminServiceClient) OnRelaunchExecutionMatch(matchers ...interface{}) *AdminServiceClient_RelaunchExecution {
	c := _m.On("RelaunchExecution", matchers...)
	return &AdminServiceClient_RelaunchExecution{Call: c}
}

// RelaunchExecution provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) RelaunchExecution(ctx context.Context, in *admin.ExecutionRelaunchRequest, opts ...grpc.CallOption) (*admin.ExecutionCreateResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.ExecutionCreateResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ExecutionRelaunchRequest, ...grpc.CallOption) *admin.ExecutionCreateResponse); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_TerminateExecution struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnTerminateExecution(ctx context.Context, in *admin.ExecutionTerminateRequest, opts ...grpc.CallOption) *AdminServiceClient_TerminateExecution {
	c := _m.On("TerminateExecution", ctx, in, opts)
	return &AdminServiceClient_TerminateExecution{Call: c}
}

func (_m *AdminServiceClient) OnTerminateExecutionMatch(matchers ...interface{}) *AdminServiceClient_TerminateExecution {
	c := _m.On("TerminateExecution", matchers...)
	return &AdminServiceClient_TerminateExecution{Call: c}
}

// TerminateExecution provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) TerminateExecution(ctx context.Context, in *admin.ExecutionTerminateRequest, opts ...grpc.CallOption) (*admin.ExecutionTerminateResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.ExecutionTerminateResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ExecutionTerminateRequest, ...grpc.CallOption) *admin.ExecutionTerminateResponse); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_UpdateLaunchPlan struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnUpdateLaunchPlan(ctx context.Context, in *admin.LaunchPlanUpdateRequest, opts ...grpc.CallOption) *AdminServiceClient_UpdateLaunchPlan {
	c := _m.On("UpdateLaunchPlan", ctx, in, opts)
	return &AdminServiceClient_UpdateLaunchPlan{Call: c}
}

func (_m *AdminServiceClient) OnUpdateLaunchPlanMatch(matchers ...interface{}) *AdminServiceClient_UpdateLaunchPlan {
	c := _m.On("UpdateLaunchPlan", matchers...)
	return &AdminServiceClient_UpdateLaunchPlan{Call: c}
}

// UpdateLaunchPlan provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) UpdateLaunchPlan(ctx context.Context, in *admin.LaunchPlanUpdateRequest, opts ...grpc.CallOption) (*admin.LaunchPlanUpdateResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.LaunchPlanUpdateResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.LaunchPlanUpdateRequest, ...grpc.CallOption) *admin.LaunchPlanUpdateResponse); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_UpdateNamedEntity struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnUpdateNamedEntity(ctx context.Context, in *admin.NamedEntityUpdateRequest, opts ...grpc.CallOption) *AdminServiceClient_UpdateNamedEntity {
	c := _m.On("UpdateNamedEntity", ctx, in, opts)
	return &AdminServiceClient_UpdateNamedEntity{Call: c}
}

func (_m *AdminServiceClient) OnUpdateNamedEntityMatch(matchers ...interface{}) *AdminServiceClient_UpdateNamedEntity {
	c := _m.On("UpdateNamedEntity", matchers...)
	return &AdminServiceClient_UpdateNamedEntity{Call: c}
}

// UpdateNamedEntity provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) UpdateNamedEntity(ctx context.Context, in *admin.NamedEntityUpdateRequest, opts ...grpc.CallOption) (*admin.NamedEntityUpdateResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.NamedEntityUpdateResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.NamedEntityUpdateRequest, ...grpc.CallOption) *admin.NamedEntityUpdateResponse); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_UpdateProjectDomainAttributes struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnUpdateProjectDomainAttributes(ctx context.Context, in *admin.ProjectDomainAttributesUpdateRequest, opts ...grpc.CallOption) *AdminServiceClient_UpdateProjectDomainAttributes {
	c := _m.On("UpdateProjectDomainAttributes", ctx, in, opts)
	return &AdminServiceClient_UpdateProjectDomainAttributes{Call: c}
}

func (_m *AdminServiceClient) OnUpdateProjectDomainAttributesMatch(matchers ...interface{}) *AdminServiceClient_UpdateProjectDomainAttributes {
	c := _m.On("UpdateProjectDomainAttributes", matchers...)
	return &AdminServiceClient_UpdateProjectDomainAttributes{Call: c}
}

// UpdateProjectDomainAttributes provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) UpdateProjectDomainAttributes(ctx context.Context, in *admin.ProjectDomainAttributesUpdateRequest, opts ...grpc.CallOption) (*admin.ProjectDomainAttributesUpdateResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.ProjectDomainAttributesUpdateResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.ProjectDomainAttributesUpdateRequest, ...grpc.CallOption) *admin.ProjectDomainAttributesUpdateResponse); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

type AdminServiceClient_UpdateWorkflowAttributes struct {
	*mock.Call
}

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

func (_m *AdminServiceClient) OnUpdateWorkflowAttributes(ctx context.Context, in *admin.WorkflowAttributesUpdateRequest, opts ...grpc.CallOption) *AdminServiceClient_UpdateWorkflowAttributes {
	c := _m.On("UpdateWorkflowAttributes", ctx, in, opts)
	return &AdminServiceClient_UpdateWorkflowAttributes{Call: c}
}

func (_m *AdminServiceClient) OnUpdateWorkflowAttributesMatch(matchers ...interface{}) *AdminServiceClient_UpdateWorkflowAttributes {
	c := _m.On("UpdateWorkflowAttributes", matchers...)
	return &AdminServiceClient_UpdateWorkflowAttributes{Call: c}
}

// UpdateWorkflowAttributes provides a mock function with given fields: ctx, in, opts
func (_m *AdminServiceClient) UpdateWorkflowAttributes(ctx context.Context, in *admin.WorkflowAttributesUpdateRequest, opts ...grpc.CallOption) (*admin.WorkflowAttributesUpdateResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 *admin.WorkflowAttributesUpdateResponse
	if rf, ok := ret.Get(0).(func(context.Context, *admin.WorkflowAttributesUpdateRequest, ...grpc.CallOption) *admin.WorkflowAttributesUpdateResponse); ok {
		r0 = rf(ctx, in, opts...)
	} 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, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}