mocks

package

Go to main page

Versions in this module

v1

v1.14.1

Dec 20, 2024

v1.14.0

Dec 6, 2024

v1.13.9

Dec 2, 2024

v1.13.8

Dec 2, 2024

v1.13.7

Nov 15, 2024

v1.13.6

Nov 12, 2024

v1.13.5

Oct 23, 2024

v1.13.4

Sep 16, 2024

v1.13.3

Aug 28, 2024

v1.13.2

Aug 14, 2024

v1.13.1

Aug 8, 2024

v1.13.0

Jul 3, 2024

Changes in this version

type AdminServiceClient

+ func (_m *AdminServiceClient) GetDomains(ctx context.Context, in *admin.GetDomainRequest, opts ...grpc.CallOption) (*admin.GetDomainsResponse, error)

+ func (_m *AdminServiceClient) OnGetDomains(ctx context.Context, in *admin.GetDomainRequest, opts ...grpc.CallOption) *AdminServiceClient_GetDomains

+ func (_m *AdminServiceClient) OnGetDomainsMatch(matchers ...interface{}) *AdminServiceClient_GetDomains

+ type AdminServiceClient_GetDomains struct

+ func (_m AdminServiceClient_GetDomains) Return(_a0 *admin.GetDomainsResponse, _a1 error) *AdminServiceClient_GetDomains

type AdminServiceServer

+ func (_m *AdminServiceServer) GetDomains(_a0 context.Context, _a1 *admin.GetDomainRequest) (*admin.GetDomainsResponse, error)

+ func (_m *AdminServiceServer) OnGetDomains(_a0 context.Context, _a1 *admin.GetDomainRequest) *AdminServiceServer_GetDomains

+ func (_m *AdminServiceServer) OnGetDomainsMatch(matchers ...interface{}) *AdminServiceServer_GetDomains

+ type AdminServiceServer_GetDomains struct

+ func (_m AdminServiceServer_GetDomains) Return(_a0 *admin.GetDomainsResponse, _a1 error) *AdminServiceServer_GetDomains

v1.13.0-rc0

Jun 26, 2024

v1.12.1-rc0

May 31, 2024

v1.12.0

May 6, 2024

Changes in this version

type AdminServiceClient

+ func (_m *AdminServiceClient) GetProject(ctx context.Context, in *admin.ProjectGetRequest, opts ...grpc.CallOption) (*admin.Project, error)

+ func (_m *AdminServiceClient) OnGetProject(ctx context.Context, in *admin.ProjectGetRequest, opts ...grpc.CallOption) *AdminServiceClient_GetProject

+ func (_m *AdminServiceClient) OnGetProjectMatch(matchers ...interface{}) *AdminServiceClient_GetProject

+ type AdminServiceClient_GetProject struct

+ func (_m AdminServiceClient_GetProject) Return(_a0 *admin.Project, _a1 error) *AdminServiceClient_GetProject

type AdminServiceServer

+ func (_m *AdminServiceServer) GetProject(_a0 context.Context, _a1 *admin.ProjectGetRequest) (*admin.Project, error)

+ func (_m *AdminServiceServer) OnGetProject(_a0 context.Context, _a1 *admin.ProjectGetRequest) *AdminServiceServer_GetProject

+ func (_m *AdminServiceServer) OnGetProjectMatch(matchers ...interface{}) *AdminServiceServer_GetProject

+ type AdminServiceServer_GetProject struct

+ func (_m AdminServiceServer_GetProject) Return(_a0 *admin.Project, _a1 error) *AdminServiceServer_GetProject

v1.12.0-b0

Apr 29, 2024

v1.11.1-b1

Mar 29, 2024

v1.11.1-b0

Mar 21, 2024

v1.11.0

Mar 12, 2024

Changes in this version

+ type AsyncAgentService_CreateTaskClient struct

+ func (_m *AsyncAgentService_CreateTaskClient) CloseAndRecv() (*admin.CreateTaskResponse, error)

+ func (_m *AsyncAgentService_CreateTaskClient) CloseSend() error

+ func (_m *AsyncAgentService_CreateTaskClient) Context() context.Context

+ func (_m *AsyncAgentService_CreateTaskClient) Header() (metadata.MD, error)

+ func (_m *AsyncAgentService_CreateTaskClient) OnCloseAndRecv() *AsyncAgentService_CreateTaskClient_CloseAndRecv

+ func (_m *AsyncAgentService_CreateTaskClient) OnCloseAndRecvMatch(matchers ...interface{}) *AsyncAgentService_CreateTaskClient_CloseAndRecv

+ func (_m *AsyncAgentService_CreateTaskClient) OnCloseSend() *AsyncAgentService_CreateTaskClient_CloseSend

+ func (_m *AsyncAgentService_CreateTaskClient) OnCloseSendMatch(matchers ...interface{}) *AsyncAgentService_CreateTaskClient_CloseSend

+ func (_m *AsyncAgentService_CreateTaskClient) OnContext() *AsyncAgentService_CreateTaskClient_Context

+ func (_m *AsyncAgentService_CreateTaskClient) OnContextMatch(matchers ...interface{}) *AsyncAgentService_CreateTaskClient_Context

+ func (_m *AsyncAgentService_CreateTaskClient) OnHeader() *AsyncAgentService_CreateTaskClient_Header

+ func (_m *AsyncAgentService_CreateTaskClient) OnHeaderMatch(matchers ...interface{}) *AsyncAgentService_CreateTaskClient_Header

+ func (_m *AsyncAgentService_CreateTaskClient) OnRecvMsg(m interface{}) *AsyncAgentService_CreateTaskClient_RecvMsg

+ func (_m *AsyncAgentService_CreateTaskClient) OnRecvMsgMatch(matchers ...interface{}) *AsyncAgentService_CreateTaskClient_RecvMsg

+ func (_m *AsyncAgentService_CreateTaskClient) OnSend(_a0 *admin.CreateTaskRequest) *AsyncAgentService_CreateTaskClient_Send

+ func (_m *AsyncAgentService_CreateTaskClient) OnSendMatch(matchers ...interface{}) *AsyncAgentService_CreateTaskClient_Send

+ func (_m *AsyncAgentService_CreateTaskClient) OnSendMsg(m interface{}) *AsyncAgentService_CreateTaskClient_SendMsg

+ func (_m *AsyncAgentService_CreateTaskClient) OnSendMsgMatch(matchers ...interface{}) *AsyncAgentService_CreateTaskClient_SendMsg

+ func (_m *AsyncAgentService_CreateTaskClient) OnTrailer() *AsyncAgentService_CreateTaskClient_Trailer

+ func (_m *AsyncAgentService_CreateTaskClient) OnTrailerMatch(matchers ...interface{}) *AsyncAgentService_CreateTaskClient_Trailer

+ func (_m *AsyncAgentService_CreateTaskClient) RecvMsg(m interface{}) error

+ func (_m *AsyncAgentService_CreateTaskClient) Send(_a0 *admin.CreateTaskRequest) error

+ func (_m *AsyncAgentService_CreateTaskClient) SendMsg(m interface{}) error

+ func (_m *AsyncAgentService_CreateTaskClient) Trailer() metadata.MD

+ type AsyncAgentService_CreateTaskClient_CloseAndRecv struct

+ func (_m AsyncAgentService_CreateTaskClient_CloseAndRecv) Return(_a0 *admin.CreateTaskResponse, _a1 error) *AsyncAgentService_CreateTaskClient_CloseAndRecv

+ type AsyncAgentService_CreateTaskClient_CloseSend struct

+ func (_m AsyncAgentService_CreateTaskClient_CloseSend) Return(_a0 error) *AsyncAgentService_CreateTaskClient_CloseSend

+ type AsyncAgentService_CreateTaskClient_Context struct

+ func (_m AsyncAgentService_CreateTaskClient_Context) Return(_a0 context.Context) *AsyncAgentService_CreateTaskClient_Context

+ type AsyncAgentService_CreateTaskClient_Header struct

+ func (_m AsyncAgentService_CreateTaskClient_Header) Return(_a0 metadata.MD, _a1 error) *AsyncAgentService_CreateTaskClient_Header

+ type AsyncAgentService_CreateTaskClient_RecvMsg struct

+ func (_m AsyncAgentService_CreateTaskClient_RecvMsg) Return(_a0 error) *AsyncAgentService_CreateTaskClient_RecvMsg

+ type AsyncAgentService_CreateTaskClient_Send struct

+ func (_m AsyncAgentService_CreateTaskClient_Send) Return(_a0 error) *AsyncAgentService_CreateTaskClient_Send

+ type AsyncAgentService_CreateTaskClient_SendMsg struct

+ func (_m AsyncAgentService_CreateTaskClient_SendMsg) Return(_a0 error) *AsyncAgentService_CreateTaskClient_SendMsg

+ type AsyncAgentService_CreateTaskClient_Trailer struct

+ func (_m AsyncAgentService_CreateTaskClient_Trailer) Return(_a0 metadata.MD) *AsyncAgentService_CreateTaskClient_Trailer

+ type AsyncAgentService_CreateTaskServer struct

+ func (_m *AsyncAgentService_CreateTaskServer) Context() context.Context

+ func (_m *AsyncAgentService_CreateTaskServer) OnContext() *AsyncAgentService_CreateTaskServer_Context

+ func (_m *AsyncAgentService_CreateTaskServer) OnContextMatch(matchers ...interface{}) *AsyncAgentService_CreateTaskServer_Context

+ func (_m *AsyncAgentService_CreateTaskServer) OnRecv() *AsyncAgentService_CreateTaskServer_Recv

+ func (_m *AsyncAgentService_CreateTaskServer) OnRecvMatch(matchers ...interface{}) *AsyncAgentService_CreateTaskServer_Recv

+ func (_m *AsyncAgentService_CreateTaskServer) OnRecvMsg(m interface{}) *AsyncAgentService_CreateTaskServer_RecvMsg

+ func (_m *AsyncAgentService_CreateTaskServer) OnRecvMsgMatch(matchers ...interface{}) *AsyncAgentService_CreateTaskServer_RecvMsg

+ func (_m *AsyncAgentService_CreateTaskServer) OnSendAndClose(_a0 *admin.CreateTaskResponse) *AsyncAgentService_CreateTaskServer_SendAndClose

+ func (_m *AsyncAgentService_CreateTaskServer) OnSendAndCloseMatch(matchers ...interface{}) *AsyncAgentService_CreateTaskServer_SendAndClose

+ func (_m *AsyncAgentService_CreateTaskServer) OnSendHeader(_a0 metadata.MD) *AsyncAgentService_CreateTaskServer_SendHeader

+ func (_m *AsyncAgentService_CreateTaskServer) OnSendHeaderMatch(matchers ...interface{}) *AsyncAgentService_CreateTaskServer_SendHeader

+ func (_m *AsyncAgentService_CreateTaskServer) OnSendMsg(m interface{}) *AsyncAgentService_CreateTaskServer_SendMsg

+ func (_m *AsyncAgentService_CreateTaskServer) OnSendMsgMatch(matchers ...interface{}) *AsyncAgentService_CreateTaskServer_SendMsg

+ func (_m *AsyncAgentService_CreateTaskServer) OnSetHeader(_a0 metadata.MD) *AsyncAgentService_CreateTaskServer_SetHeader

+ func (_m *AsyncAgentService_CreateTaskServer) OnSetHeaderMatch(matchers ...interface{}) *AsyncAgentService_CreateTaskServer_SetHeader

+ func (_m *AsyncAgentService_CreateTaskServer) Recv() (*admin.CreateTaskRequest, error)

+ func (_m *AsyncAgentService_CreateTaskServer) RecvMsg(m interface{}) error

+ func (_m *AsyncAgentService_CreateTaskServer) SendAndClose(_a0 *admin.CreateTaskResponse) error

+ func (_m *AsyncAgentService_CreateTaskServer) SendHeader(_a0 metadata.MD) error

+ func (_m *AsyncAgentService_CreateTaskServer) SendMsg(m interface{}) error

+ func (_m *AsyncAgentService_CreateTaskServer) SetHeader(_a0 metadata.MD) error

+ func (_m *AsyncAgentService_CreateTaskServer) SetTrailer(_a0 metadata.MD)

+ type AsyncAgentService_CreateTaskServer_Context struct

+ func (_m AsyncAgentService_CreateTaskServer_Context) Return(_a0 context.Context) *AsyncAgentService_CreateTaskServer_Context

+ type AsyncAgentService_CreateTaskServer_Recv struct

+ func (_m AsyncAgentService_CreateTaskServer_Recv) Return(_a0 *admin.CreateTaskRequest, _a1 error) *AsyncAgentService_CreateTaskServer_Recv

+ type AsyncAgentService_CreateTaskServer_RecvMsg struct

+ func (_m AsyncAgentService_CreateTaskServer_RecvMsg) Return(_a0 error) *AsyncAgentService_CreateTaskServer_RecvMsg

+ type AsyncAgentService_CreateTaskServer_SendAndClose struct

+ func (_m AsyncAgentService_CreateTaskServer_SendAndClose) Return(_a0 error) *AsyncAgentService_CreateTaskServer_SendAndClose

+ type AsyncAgentService_CreateTaskServer_SendHeader struct

+ func (_m AsyncAgentService_CreateTaskServer_SendHeader) Return(_a0 error) *AsyncAgentService_CreateTaskServer_SendHeader

+ type AsyncAgentService_CreateTaskServer_SendMsg struct

+ func (_m AsyncAgentService_CreateTaskServer_SendMsg) Return(_a0 error) *AsyncAgentService_CreateTaskServer_SendMsg

+ type AsyncAgentService_CreateTaskServer_SetHeader struct

+ func (_m AsyncAgentService_CreateTaskServer_SetHeader) Return(_a0 error) *AsyncAgentService_CreateTaskServer_SetHeader

+ type AsyncAgentService_ExecuteTaskSyncClient struct

+ func (_m *AsyncAgentService_ExecuteTaskSyncClient) CloseSend() error

+ func (_m *AsyncAgentService_ExecuteTaskSyncClient) Context() context.Context

+ func (_m *AsyncAgentService_ExecuteTaskSyncClient) Header() (metadata.MD, error)

+ func (_m *AsyncAgentService_ExecuteTaskSyncClient) OnCloseSend() *AsyncAgentService_ExecuteTaskSyncClient_CloseSend

+ func (_m *AsyncAgentService_ExecuteTaskSyncClient) OnCloseSendMatch(matchers ...interface{}) *AsyncAgentService_ExecuteTaskSyncClient_CloseSend

+ func (_m *AsyncAgentService_ExecuteTaskSyncClient) OnContext() *AsyncAgentService_ExecuteTaskSyncClient_Context

+ func (_m *AsyncAgentService_ExecuteTaskSyncClient) OnContextMatch(matchers ...interface{}) *AsyncAgentService_ExecuteTaskSyncClient_Context

+ func (_m *AsyncAgentService_ExecuteTaskSyncClient) OnHeader() *AsyncAgentService_ExecuteTaskSyncClient_Header

+ func (_m *AsyncAgentService_ExecuteTaskSyncClient) OnHeaderMatch(matchers ...interface{}) *AsyncAgentService_ExecuteTaskSyncClient_Header

+ func (_m *AsyncAgentService_ExecuteTaskSyncClient) OnRecv() *AsyncAgentService_ExecuteTaskSyncClient_Recv

+ func (_m *AsyncAgentService_ExecuteTaskSyncClient) OnRecvMatch(matchers ...interface{}) *AsyncAgentService_ExecuteTaskSyncClient_Recv

+ func (_m *AsyncAgentService_ExecuteTaskSyncClient) OnRecvMsg(m interface{}) *AsyncAgentService_ExecuteTaskSyncClient_RecvMsg

+ func (_m *AsyncAgentService_ExecuteTaskSyncClient) OnRecvMsgMatch(matchers ...interface{}) *AsyncAgentService_ExecuteTaskSyncClient_RecvMsg

+ func (_m *AsyncAgentService_ExecuteTaskSyncClient) OnSend(_a0 *admin.ExecuteTaskSyncRequest) *AsyncAgentService_ExecuteTaskSyncClient_Send

+ func (_m *AsyncAgentService_ExecuteTaskSyncClient) OnSendMatch(matchers ...interface{}) *AsyncAgentService_ExecuteTaskSyncClient_Send

+ func (_m *AsyncAgentService_ExecuteTaskSyncClient) OnSendMsg(m interface{}) *AsyncAgentService_ExecuteTaskSyncClient_SendMsg

+ func (_m *AsyncAgentService_ExecuteTaskSyncClient) OnSendMsgMatch(matchers ...interface{}) *AsyncAgentService_ExecuteTaskSyncClient_SendMsg

+ func (_m *AsyncAgentService_ExecuteTaskSyncClient) OnTrailer() *AsyncAgentService_ExecuteTaskSyncClient_Trailer

+ func (_m *AsyncAgentService_ExecuteTaskSyncClient) OnTrailerMatch(matchers ...interface{}) *AsyncAgentService_ExecuteTaskSyncClient_Trailer

+ func (_m *AsyncAgentService_ExecuteTaskSyncClient) Recv() (*admin.ExecuteTaskSyncResponse, error)

+ func (_m *AsyncAgentService_ExecuteTaskSyncClient) RecvMsg(m interface{}) error

+ func (_m *AsyncAgentService_ExecuteTaskSyncClient) Send(_a0 *admin.ExecuteTaskSyncRequest) error

+ func (_m *AsyncAgentService_ExecuteTaskSyncClient) SendMsg(m interface{}) error

+ func (_m *AsyncAgentService_ExecuteTaskSyncClient) Trailer() metadata.MD

+ type AsyncAgentService_ExecuteTaskSyncClient_CloseSend struct

+ func (_m AsyncAgentService_ExecuteTaskSyncClient_CloseSend) Return(_a0 error) *AsyncAgentService_ExecuteTaskSyncClient_CloseSend

+ type AsyncAgentService_ExecuteTaskSyncClient_Context struct

+ func (_m AsyncAgentService_ExecuteTaskSyncClient_Context) Return(_a0 context.Context) *AsyncAgentService_ExecuteTaskSyncClient_Context

+ type AsyncAgentService_ExecuteTaskSyncClient_Header struct

+ func (_m AsyncAgentService_ExecuteTaskSyncClient_Header) Return(_a0 metadata.MD, _a1 error) *AsyncAgentService_ExecuteTaskSyncClient_Header

+ type AsyncAgentService_ExecuteTaskSyncClient_Recv struct

+ func (_m AsyncAgentService_ExecuteTaskSyncClient_Recv) Return(_a0 *admin.ExecuteTaskSyncResponse, _a1 error) *AsyncAgentService_ExecuteTaskSyncClient_Recv

+ type AsyncAgentService_ExecuteTaskSyncClient_RecvMsg struct

+ func (_m AsyncAgentService_ExecuteTaskSyncClient_RecvMsg) Return(_a0 error) *AsyncAgentService_ExecuteTaskSyncClient_RecvMsg

+ type AsyncAgentService_ExecuteTaskSyncClient_Send struct

+ func (_m AsyncAgentService_ExecuteTaskSyncClient_Send) Return(_a0 error) *AsyncAgentService_ExecuteTaskSyncClient_Send

+ type AsyncAgentService_ExecuteTaskSyncClient_SendMsg struct

+ func (_m AsyncAgentService_ExecuteTaskSyncClient_SendMsg) Return(_a0 error) *AsyncAgentService_ExecuteTaskSyncClient_SendMsg

+ type AsyncAgentService_ExecuteTaskSyncClient_Trailer struct

+ func (_m AsyncAgentService_ExecuteTaskSyncClient_Trailer) Return(_a0 metadata.MD) *AsyncAgentService_ExecuteTaskSyncClient_Trailer

+ type AsyncAgentService_ExecuteTaskSyncServer struct

+ func (_m *AsyncAgentService_ExecuteTaskSyncServer) Context() context.Context

+ func (_m *AsyncAgentService_ExecuteTaskSyncServer) OnContext() *AsyncAgentService_ExecuteTaskSyncServer_Context

+ func (_m *AsyncAgentService_ExecuteTaskSyncServer) OnContextMatch(matchers ...interface{}) *AsyncAgentService_ExecuteTaskSyncServer_Context

+ func (_m *AsyncAgentService_ExecuteTaskSyncServer) OnRecv() *AsyncAgentService_ExecuteTaskSyncServer_Recv

+ func (_m *AsyncAgentService_ExecuteTaskSyncServer) OnRecvMatch(matchers ...interface{}) *AsyncAgentService_ExecuteTaskSyncServer_Recv

+ func (_m *AsyncAgentService_ExecuteTaskSyncServer) OnRecvMsg(m interface{}) *AsyncAgentService_ExecuteTaskSyncServer_RecvMsg

+ func (_m *AsyncAgentService_ExecuteTaskSyncServer) OnRecvMsgMatch(matchers ...interface{}) *AsyncAgentService_ExecuteTaskSyncServer_RecvMsg

+ func (_m *AsyncAgentService_ExecuteTaskSyncServer) OnSend(_a0 *admin.ExecuteTaskSyncResponse) *AsyncAgentService_ExecuteTaskSyncServer_Send

+ func (_m *AsyncAgentService_ExecuteTaskSyncServer) OnSendHeader(_a0 metadata.MD) *AsyncAgentService_ExecuteTaskSyncServer_SendHeader

+ func (_m *AsyncAgentService_ExecuteTaskSyncServer) OnSendHeaderMatch(matchers ...interface{}) *AsyncAgentService_ExecuteTaskSyncServer_SendHeader

+ func (_m *AsyncAgentService_ExecuteTaskSyncServer) OnSendMatch(matchers ...interface{}) *AsyncAgentService_ExecuteTaskSyncServer_Send

+ func (_m *AsyncAgentService_ExecuteTaskSyncServer) OnSendMsg(m interface{}) *AsyncAgentService_ExecuteTaskSyncServer_SendMsg

+ func (_m *AsyncAgentService_ExecuteTaskSyncServer) OnSendMsgMatch(matchers ...interface{}) *AsyncAgentService_ExecuteTaskSyncServer_SendMsg

+ func (_m *AsyncAgentService_ExecuteTaskSyncServer) OnSetHeader(_a0 metadata.MD) *AsyncAgentService_ExecuteTaskSyncServer_SetHeader

+ func (_m *AsyncAgentService_ExecuteTaskSyncServer) OnSetHeaderMatch(matchers ...interface{}) *AsyncAgentService_ExecuteTaskSyncServer_SetHeader

+ func (_m *AsyncAgentService_ExecuteTaskSyncServer) Recv() (*admin.ExecuteTaskSyncRequest, error)

+ func (_m *AsyncAgentService_ExecuteTaskSyncServer) RecvMsg(m interface{}) error

+ func (_m *AsyncAgentService_ExecuteTaskSyncServer) Send(_a0 *admin.ExecuteTaskSyncResponse) error

+ func (_m *AsyncAgentService_ExecuteTaskSyncServer) SendHeader(_a0 metadata.MD) error

+ func (_m *AsyncAgentService_ExecuteTaskSyncServer) SendMsg(m interface{}) error

+ func (_m *AsyncAgentService_ExecuteTaskSyncServer) SetHeader(_a0 metadata.MD) error

+ func (_m *AsyncAgentService_ExecuteTaskSyncServer) SetTrailer(_a0 metadata.MD)

+ type AsyncAgentService_ExecuteTaskSyncServer_Context struct

+ func (_m AsyncAgentService_ExecuteTaskSyncServer_Context) Return(_a0 context.Context) *AsyncAgentService_ExecuteTaskSyncServer_Context

+ type AsyncAgentService_ExecuteTaskSyncServer_Recv struct

+ func (_m AsyncAgentService_ExecuteTaskSyncServer_Recv) Return(_a0 *admin.ExecuteTaskSyncRequest, _a1 error) *AsyncAgentService_ExecuteTaskSyncServer_Recv

+ type AsyncAgentService_ExecuteTaskSyncServer_RecvMsg struct

+ func (_m AsyncAgentService_ExecuteTaskSyncServer_RecvMsg) Return(_a0 error) *AsyncAgentService_ExecuteTaskSyncServer_RecvMsg

+ type AsyncAgentService_ExecuteTaskSyncServer_Send struct

+ func (_m AsyncAgentService_ExecuteTaskSyncServer_Send) Return(_a0 error) *AsyncAgentService_ExecuteTaskSyncServer_Send

+ type AsyncAgentService_ExecuteTaskSyncServer_SendHeader struct

+ func (_m AsyncAgentService_ExecuteTaskSyncServer_SendHeader) Return(_a0 error) *AsyncAgentService_ExecuteTaskSyncServer_SendHeader

+ type AsyncAgentService_ExecuteTaskSyncServer_SendMsg struct

+ func (_m AsyncAgentService_ExecuteTaskSyncServer_SendMsg) Return(_a0 error) *AsyncAgentService_ExecuteTaskSyncServer_SendMsg

+ type AsyncAgentService_ExecuteTaskSyncServer_SetHeader struct

+ func (_m AsyncAgentService_ExecuteTaskSyncServer_SetHeader) Return(_a0 error) *AsyncAgentService_ExecuteTaskSyncServer_SetHeader

+ type AsyncAgentService_GetTaskClient struct

+ func (_m *AsyncAgentService_GetTaskClient) CloseSend() error

+ func (_m *AsyncAgentService_GetTaskClient) Context() context.Context

+ func (_m *AsyncAgentService_GetTaskClient) Header() (metadata.MD, error)

+ func (_m *AsyncAgentService_GetTaskClient) OnCloseSend() *AsyncAgentService_GetTaskClient_CloseSend

+ func (_m *AsyncAgentService_GetTaskClient) OnCloseSendMatch(matchers ...interface{}) *AsyncAgentService_GetTaskClient_CloseSend

+ func (_m *AsyncAgentService_GetTaskClient) OnContext() *AsyncAgentService_GetTaskClient_Context

+ func (_m *AsyncAgentService_GetTaskClient) OnContextMatch(matchers ...interface{}) *AsyncAgentService_GetTaskClient_Context

+ func (_m *AsyncAgentService_GetTaskClient) OnHeader() *AsyncAgentService_GetTaskClient_Header

+ func (_m *AsyncAgentService_GetTaskClient) OnHeaderMatch(matchers ...interface{}) *AsyncAgentService_GetTaskClient_Header

+ func (_m *AsyncAgentService_GetTaskClient) OnRecv() *AsyncAgentService_GetTaskClient_Recv

+ func (_m *AsyncAgentService_GetTaskClient) OnRecvMatch(matchers ...interface{}) *AsyncAgentService_GetTaskClient_Recv

+ func (_m *AsyncAgentService_GetTaskClient) OnRecvMsg(m interface{}) *AsyncAgentService_GetTaskClient_RecvMsg

+ func (_m *AsyncAgentService_GetTaskClient) OnRecvMsgMatch(matchers ...interface{}) *AsyncAgentService_GetTaskClient_RecvMsg

+ func (_m *AsyncAgentService_GetTaskClient) OnSendMsg(m interface{}) *AsyncAgentService_GetTaskClient_SendMsg

+ func (_m *AsyncAgentService_GetTaskClient) OnSendMsgMatch(matchers ...interface{}) *AsyncAgentService_GetTaskClient_SendMsg

+ func (_m *AsyncAgentService_GetTaskClient) OnTrailer() *AsyncAgentService_GetTaskClient_Trailer

+ func (_m *AsyncAgentService_GetTaskClient) OnTrailerMatch(matchers ...interface{}) *AsyncAgentService_GetTaskClient_Trailer

+ func (_m *AsyncAgentService_GetTaskClient) Recv() (*admin.GetTaskResponse, error)

+ func (_m *AsyncAgentService_GetTaskClient) RecvMsg(m interface{}) error

+ func (_m *AsyncAgentService_GetTaskClient) SendMsg(m interface{}) error

+ func (_m *AsyncAgentService_GetTaskClient) Trailer() metadata.MD

+ type AsyncAgentService_GetTaskClient_CloseSend struct

+ func (_m AsyncAgentService_GetTaskClient_CloseSend) Return(_a0 error) *AsyncAgentService_GetTaskClient_CloseSend

+ type AsyncAgentService_GetTaskClient_Context struct

+ func (_m AsyncAgentService_GetTaskClient_Context) Return(_a0 context.Context) *AsyncAgentService_GetTaskClient_Context

+ type AsyncAgentService_GetTaskClient_Header struct

+ func (_m AsyncAgentService_GetTaskClient_Header) Return(_a0 metadata.MD, _a1 error) *AsyncAgentService_GetTaskClient_Header

+ type AsyncAgentService_GetTaskClient_Recv struct

+ func (_m AsyncAgentService_GetTaskClient_Recv) Return(_a0 *admin.GetTaskResponse, _a1 error) *AsyncAgentService_GetTaskClient_Recv

+ type AsyncAgentService_GetTaskClient_RecvMsg struct

+ func (_m AsyncAgentService_GetTaskClient_RecvMsg) Return(_a0 error) *AsyncAgentService_GetTaskClient_RecvMsg

+ type AsyncAgentService_GetTaskClient_SendMsg struct

+ func (_m AsyncAgentService_GetTaskClient_SendMsg) Return(_a0 error) *AsyncAgentService_GetTaskClient_SendMsg

+ type AsyncAgentService_GetTaskClient_Trailer struct

+ func (_m AsyncAgentService_GetTaskClient_Trailer) Return(_a0 metadata.MD) *AsyncAgentService_GetTaskClient_Trailer

+ type AsyncAgentService_GetTaskLogsClient struct

+ func (_m *AsyncAgentService_GetTaskLogsClient) CloseSend() error

+ func (_m *AsyncAgentService_GetTaskLogsClient) Context() context.Context

+ func (_m *AsyncAgentService_GetTaskLogsClient) Header() (metadata.MD, error)

+ func (_m *AsyncAgentService_GetTaskLogsClient) OnCloseSend() *AsyncAgentService_GetTaskLogsClient_CloseSend

+ func (_m *AsyncAgentService_GetTaskLogsClient) OnCloseSendMatch(matchers ...interface{}) *AsyncAgentService_GetTaskLogsClient_CloseSend

+ func (_m *AsyncAgentService_GetTaskLogsClient) OnContext() *AsyncAgentService_GetTaskLogsClient_Context

+ func (_m *AsyncAgentService_GetTaskLogsClient) OnContextMatch(matchers ...interface{}) *AsyncAgentService_GetTaskLogsClient_Context

+ func (_m *AsyncAgentService_GetTaskLogsClient) OnHeader() *AsyncAgentService_GetTaskLogsClient_Header

+ func (_m *AsyncAgentService_GetTaskLogsClient) OnHeaderMatch(matchers ...interface{}) *AsyncAgentService_GetTaskLogsClient_Header

+ func (_m *AsyncAgentService_GetTaskLogsClient) OnRecv() *AsyncAgentService_GetTaskLogsClient_Recv

+ func (_m *AsyncAgentService_GetTaskLogsClient) OnRecvMatch(matchers ...interface{}) *AsyncAgentService_GetTaskLogsClient_Recv

+ func (_m *AsyncAgentService_GetTaskLogsClient) OnRecvMsg(m interface{}) *AsyncAgentService_GetTaskLogsClient_RecvMsg

+ func (_m *AsyncAgentService_GetTaskLogsClient) OnRecvMsgMatch(matchers ...interface{}) *AsyncAgentService_GetTaskLogsClient_RecvMsg

+ func (_m *AsyncAgentService_GetTaskLogsClient) OnSendMsg(m interface{}) *AsyncAgentService_GetTaskLogsClient_SendMsg

+ func (_m *AsyncAgentService_GetTaskLogsClient) OnSendMsgMatch(matchers ...interface{}) *AsyncAgentService_GetTaskLogsClient_SendMsg

+ func (_m *AsyncAgentService_GetTaskLogsClient) OnTrailer() *AsyncAgentService_GetTaskLogsClient_Trailer

+ func (_m *AsyncAgentService_GetTaskLogsClient) OnTrailerMatch(matchers ...interface{}) *AsyncAgentService_GetTaskLogsClient_Trailer

+ func (_m *AsyncAgentService_GetTaskLogsClient) Recv() (*admin.GetTaskLogsResponse, error)

+ func (_m *AsyncAgentService_GetTaskLogsClient) RecvMsg(m interface{}) error

+ func (_m *AsyncAgentService_GetTaskLogsClient) SendMsg(m interface{}) error

+ func (_m *AsyncAgentService_GetTaskLogsClient) Trailer() metadata.MD

+ type AsyncAgentService_GetTaskLogsClient_CloseSend struct

+ func (_m AsyncAgentService_GetTaskLogsClient_CloseSend) Return(_a0 error) *AsyncAgentService_GetTaskLogsClient_CloseSend

+ type AsyncAgentService_GetTaskLogsClient_Context struct

+ func (_m AsyncAgentService_GetTaskLogsClient_Context) Return(_a0 context.Context) *AsyncAgentService_GetTaskLogsClient_Context

+ type AsyncAgentService_GetTaskLogsClient_Header struct

+ func (_m AsyncAgentService_GetTaskLogsClient_Header) Return(_a0 metadata.MD, _a1 error) *AsyncAgentService_GetTaskLogsClient_Header

+ type AsyncAgentService_GetTaskLogsClient_Recv struct

+ func (_m AsyncAgentService_GetTaskLogsClient_Recv) Return(_a0 *admin.GetTaskLogsResponse, _a1 error) *AsyncAgentService_GetTaskLogsClient_Recv

+ type AsyncAgentService_GetTaskLogsClient_RecvMsg struct

+ func (_m AsyncAgentService_GetTaskLogsClient_RecvMsg) Return(_a0 error) *AsyncAgentService_GetTaskLogsClient_RecvMsg

+ type AsyncAgentService_GetTaskLogsClient_SendMsg struct

+ func (_m AsyncAgentService_GetTaskLogsClient_SendMsg) Return(_a0 error) *AsyncAgentService_GetTaskLogsClient_SendMsg

+ type AsyncAgentService_GetTaskLogsClient_Trailer struct

+ func (_m AsyncAgentService_GetTaskLogsClient_Trailer) Return(_a0 metadata.MD) *AsyncAgentService_GetTaskLogsClient_Trailer

+ type AsyncAgentService_GetTaskLogsServer struct

+ func (_m *AsyncAgentService_GetTaskLogsServer) Context() context.Context

+ func (_m *AsyncAgentService_GetTaskLogsServer) OnContext() *AsyncAgentService_GetTaskLogsServer_Context

+ func (_m *AsyncAgentService_GetTaskLogsServer) OnContextMatch(matchers ...interface{}) *AsyncAgentService_GetTaskLogsServer_Context

+ func (_m *AsyncAgentService_GetTaskLogsServer) OnRecvMsg(m interface{}) *AsyncAgentService_GetTaskLogsServer_RecvMsg

+ func (_m *AsyncAgentService_GetTaskLogsServer) OnRecvMsgMatch(matchers ...interface{}) *AsyncAgentService_GetTaskLogsServer_RecvMsg

+ func (_m *AsyncAgentService_GetTaskLogsServer) OnSend(_a0 *admin.GetTaskLogsResponse) *AsyncAgentService_GetTaskLogsServer_Send

+ func (_m *AsyncAgentService_GetTaskLogsServer) OnSendHeader(_a0 metadata.MD) *AsyncAgentService_GetTaskLogsServer_SendHeader

+ func (_m *AsyncAgentService_GetTaskLogsServer) OnSendHeaderMatch(matchers ...interface{}) *AsyncAgentService_GetTaskLogsServer_SendHeader

+ func (_m *AsyncAgentService_GetTaskLogsServer) OnSendMatch(matchers ...interface{}) *AsyncAgentService_GetTaskLogsServer_Send

+ func (_m *AsyncAgentService_GetTaskLogsServer) OnSendMsg(m interface{}) *AsyncAgentService_GetTaskLogsServer_SendMsg

+ func (_m *AsyncAgentService_GetTaskLogsServer) OnSendMsgMatch(matchers ...interface{}) *AsyncAgentService_GetTaskLogsServer_SendMsg

+ func (_m *AsyncAgentService_GetTaskLogsServer) OnSetHeader(_a0 metadata.MD) *AsyncAgentService_GetTaskLogsServer_SetHeader

+ func (_m *AsyncAgentService_GetTaskLogsServer) OnSetHeaderMatch(matchers ...interface{}) *AsyncAgentService_GetTaskLogsServer_SetHeader

+ func (_m *AsyncAgentService_GetTaskLogsServer) RecvMsg(m interface{}) error

+ func (_m *AsyncAgentService_GetTaskLogsServer) Send(_a0 *admin.GetTaskLogsResponse) error

+ func (_m *AsyncAgentService_GetTaskLogsServer) SendHeader(_a0 metadata.MD) error

+ func (_m *AsyncAgentService_GetTaskLogsServer) SendMsg(m interface{}) error

+ func (_m *AsyncAgentService_GetTaskLogsServer) SetHeader(_a0 metadata.MD) error

+ func (_m *AsyncAgentService_GetTaskLogsServer) SetTrailer(_a0 metadata.MD)

+ type AsyncAgentService_GetTaskLogsServer_Context struct

+ func (_m AsyncAgentService_GetTaskLogsServer_Context) Return(_a0 context.Context) *AsyncAgentService_GetTaskLogsServer_Context

+ type AsyncAgentService_GetTaskLogsServer_RecvMsg struct

+ func (_m AsyncAgentService_GetTaskLogsServer_RecvMsg) Return(_a0 error) *AsyncAgentService_GetTaskLogsServer_RecvMsg

+ type AsyncAgentService_GetTaskLogsServer_Send struct

+ func (_m AsyncAgentService_GetTaskLogsServer_Send) Return(_a0 error) *AsyncAgentService_GetTaskLogsServer_Send

+ type AsyncAgentService_GetTaskLogsServer_SendHeader struct

+ func (_m AsyncAgentService_GetTaskLogsServer_SendHeader) Return(_a0 error) *AsyncAgentService_GetTaskLogsServer_SendHeader

+ type AsyncAgentService_GetTaskLogsServer_SendMsg struct

+ func (_m AsyncAgentService_GetTaskLogsServer_SendMsg) Return(_a0 error) *AsyncAgentService_GetTaskLogsServer_SendMsg

+ type AsyncAgentService_GetTaskLogsServer_SetHeader struct

+ func (_m AsyncAgentService_GetTaskLogsServer_SetHeader) Return(_a0 error) *AsyncAgentService_GetTaskLogsServer_SetHeader

+ type AsyncAgentService_GetTaskServer struct

+ func (_m *AsyncAgentService_GetTaskServer) Context() context.Context

+ func (_m *AsyncAgentService_GetTaskServer) OnContext() *AsyncAgentService_GetTaskServer_Context

+ func (_m *AsyncAgentService_GetTaskServer) OnContextMatch(matchers ...interface{}) *AsyncAgentService_GetTaskServer_Context

+ func (_m *AsyncAgentService_GetTaskServer) OnRecvMsg(m interface{}) *AsyncAgentService_GetTaskServer_RecvMsg

+ func (_m *AsyncAgentService_GetTaskServer) OnRecvMsgMatch(matchers ...interface{}) *AsyncAgentService_GetTaskServer_RecvMsg

+ func (_m *AsyncAgentService_GetTaskServer) OnSend(_a0 *admin.GetTaskResponse) *AsyncAgentService_GetTaskServer_Send

+ func (_m *AsyncAgentService_GetTaskServer) OnSendHeader(_a0 metadata.MD) *AsyncAgentService_GetTaskServer_SendHeader

+ func (_m *AsyncAgentService_GetTaskServer) OnSendHeaderMatch(matchers ...interface{}) *AsyncAgentService_GetTaskServer_SendHeader

+ func (_m *AsyncAgentService_GetTaskServer) OnSendMatch(matchers ...interface{}) *AsyncAgentService_GetTaskServer_Send

+ func (_m *AsyncAgentService_GetTaskServer) OnSendMsg(m interface{}) *AsyncAgentService_GetTaskServer_SendMsg

+ func (_m *AsyncAgentService_GetTaskServer) OnSendMsgMatch(matchers ...interface{}) *AsyncAgentService_GetTaskServer_SendMsg

+ func (_m *AsyncAgentService_GetTaskServer) OnSetHeader(_a0 metadata.MD) *AsyncAgentService_GetTaskServer_SetHeader

+ func (_m *AsyncAgentService_GetTaskServer) OnSetHeaderMatch(matchers ...interface{}) *AsyncAgentService_GetTaskServer_SetHeader

+ func (_m *AsyncAgentService_GetTaskServer) RecvMsg(m interface{}) error

+ func (_m *AsyncAgentService_GetTaskServer) Send(_a0 *admin.GetTaskResponse) error

+ func (_m *AsyncAgentService_GetTaskServer) SendHeader(_a0 metadata.MD) error

+ func (_m *AsyncAgentService_GetTaskServer) SendMsg(m interface{}) error

+ func (_m *AsyncAgentService_GetTaskServer) SetHeader(_a0 metadata.MD) error

+ func (_m *AsyncAgentService_GetTaskServer) SetTrailer(_a0 metadata.MD)

+ type AsyncAgentService_GetTaskServer_Context struct

+ func (_m AsyncAgentService_GetTaskServer_Context) Return(_a0 context.Context) *AsyncAgentService_GetTaskServer_Context

+ type AsyncAgentService_GetTaskServer_RecvMsg struct

+ func (_m AsyncAgentService_GetTaskServer_RecvMsg) Return(_a0 error) *AsyncAgentService_GetTaskServer_RecvMsg

+ type AsyncAgentService_GetTaskServer_Send struct

+ func (_m AsyncAgentService_GetTaskServer_Send) Return(_a0 error) *AsyncAgentService_GetTaskServer_Send

+ type AsyncAgentService_GetTaskServer_SendHeader struct

+ func (_m AsyncAgentService_GetTaskServer_SendHeader) Return(_a0 error) *AsyncAgentService_GetTaskServer_SendHeader

+ type AsyncAgentService_GetTaskServer_SendMsg struct

+ func (_m AsyncAgentService_GetTaskServer_SendMsg) Return(_a0 error) *AsyncAgentService_GetTaskServer_SendMsg

+ type AsyncAgentService_GetTaskServer_SetHeader struct

+ func (_m AsyncAgentService_GetTaskServer_SetHeader) Return(_a0 error) *AsyncAgentService_GetTaskServer_SetHeader

+ type SyncAgentServiceClient struct

+ func (_m *SyncAgentServiceClient) ExecuteTaskSync(ctx context.Context, opts ...grpc.CallOption) (service.SyncAgentService_ExecuteTaskSyncClient, error)

+ func (_m *SyncAgentServiceClient) OnExecuteTaskSync(ctx context.Context, opts ...grpc.CallOption) *SyncAgentServiceClient_ExecuteTaskSync

+ func (_m *SyncAgentServiceClient) OnExecuteTaskSyncMatch(matchers ...interface{}) *SyncAgentServiceClient_ExecuteTaskSync

+ type SyncAgentServiceClient_ExecuteTaskSync struct

+ func (_m SyncAgentServiceClient_ExecuteTaskSync) Return(_a0 service.SyncAgentService_ExecuteTaskSyncClient, _a1 error) *SyncAgentServiceClient_ExecuteTaskSync

+ type SyncAgentServiceServer struct

+ func (_m *SyncAgentServiceServer) ExecuteTaskSync(_a0 service.SyncAgentService_ExecuteTaskSyncServer) error

+ func (_m *SyncAgentServiceServer) OnExecuteTaskSync(_a0 service.SyncAgentService_ExecuteTaskSyncServer) *SyncAgentServiceServer_ExecuteTaskSync

+ func (_m *SyncAgentServiceServer) OnExecuteTaskSyncMatch(matchers ...interface{}) *SyncAgentServiceServer_ExecuteTaskSync

+ type SyncAgentServiceServer_ExecuteTaskSync struct

+ func (_m SyncAgentServiceServer_ExecuteTaskSync) Return(_a0 error) *SyncAgentServiceServer_ExecuteTaskSync

+ type SyncAgentService_ExecuteTaskSyncClient struct

+ func (_m *SyncAgentService_ExecuteTaskSyncClient) CloseSend() error

+ func (_m *SyncAgentService_ExecuteTaskSyncClient) Context() context.Context

+ func (_m *SyncAgentService_ExecuteTaskSyncClient) Header() (metadata.MD, error)

+ func (_m *SyncAgentService_ExecuteTaskSyncClient) OnCloseSend() *SyncAgentService_ExecuteTaskSyncClient_CloseSend

+ func (_m *SyncAgentService_ExecuteTaskSyncClient) OnCloseSendMatch(matchers ...interface{}) *SyncAgentService_ExecuteTaskSyncClient_CloseSend

+ func (_m *SyncAgentService_ExecuteTaskSyncClient) OnContext() *SyncAgentService_ExecuteTaskSyncClient_Context

+ func (_m *SyncAgentService_ExecuteTaskSyncClient) OnContextMatch(matchers ...interface{}) *SyncAgentService_ExecuteTaskSyncClient_Context

+ func (_m *SyncAgentService_ExecuteTaskSyncClient) OnHeader() *SyncAgentService_ExecuteTaskSyncClient_Header

+ func (_m *SyncAgentService_ExecuteTaskSyncClient) OnHeaderMatch(matchers ...interface{}) *SyncAgentService_ExecuteTaskSyncClient_Header

+ func (_m *SyncAgentService_ExecuteTaskSyncClient) OnRecv() *SyncAgentService_ExecuteTaskSyncClient_Recv

+ func (_m *SyncAgentService_ExecuteTaskSyncClient) OnRecvMatch(matchers ...interface{}) *SyncAgentService_ExecuteTaskSyncClient_Recv

+ func (_m *SyncAgentService_ExecuteTaskSyncClient) OnRecvMsg(m interface{}) *SyncAgentService_ExecuteTaskSyncClient_RecvMsg

+ func (_m *SyncAgentService_ExecuteTaskSyncClient) OnRecvMsgMatch(matchers ...interface{}) *SyncAgentService_ExecuteTaskSyncClient_RecvMsg

+ func (_m *SyncAgentService_ExecuteTaskSyncClient) OnSend(_a0 *admin.ExecuteTaskSyncRequest) *SyncAgentService_ExecuteTaskSyncClient_Send

+ func (_m *SyncAgentService_ExecuteTaskSyncClient) OnSendMatch(matchers ...interface{}) *SyncAgentService_ExecuteTaskSyncClient_Send

+ func (_m *SyncAgentService_ExecuteTaskSyncClient) OnSendMsg(m interface{}) *SyncAgentService_ExecuteTaskSyncClient_SendMsg

+ func (_m *SyncAgentService_ExecuteTaskSyncClient) OnSendMsgMatch(matchers ...interface{}) *SyncAgentService_ExecuteTaskSyncClient_SendMsg

+ func (_m *SyncAgentService_ExecuteTaskSyncClient) OnTrailer() *SyncAgentService_ExecuteTaskSyncClient_Trailer

+ func (_m *SyncAgentService_ExecuteTaskSyncClient) OnTrailerMatch(matchers ...interface{}) *SyncAgentService_ExecuteTaskSyncClient_Trailer

+ func (_m *SyncAgentService_ExecuteTaskSyncClient) Recv() (*admin.ExecuteTaskSyncResponse, error)

+ func (_m *SyncAgentService_ExecuteTaskSyncClient) RecvMsg(m interface{}) error

+ func (_m *SyncAgentService_ExecuteTaskSyncClient) Send(_a0 *admin.ExecuteTaskSyncRequest) error

+ func (_m *SyncAgentService_ExecuteTaskSyncClient) SendMsg(m interface{}) error

+ func (_m *SyncAgentService_ExecuteTaskSyncClient) Trailer() metadata.MD

+ type SyncAgentService_ExecuteTaskSyncClient_CloseSend struct

+ func (_m SyncAgentService_ExecuteTaskSyncClient_CloseSend) Return(_a0 error) *SyncAgentService_ExecuteTaskSyncClient_CloseSend

+ type SyncAgentService_ExecuteTaskSyncClient_Context struct

+ func (_m SyncAgentService_ExecuteTaskSyncClient_Context) Return(_a0 context.Context) *SyncAgentService_ExecuteTaskSyncClient_Context

+ type SyncAgentService_ExecuteTaskSyncClient_Header struct

+ func (_m SyncAgentService_ExecuteTaskSyncClient_Header) Return(_a0 metadata.MD, _a1 error) *SyncAgentService_ExecuteTaskSyncClient_Header

+ type SyncAgentService_ExecuteTaskSyncClient_Recv struct

+ func (_m SyncAgentService_ExecuteTaskSyncClient_Recv) Return(_a0 *admin.ExecuteTaskSyncResponse, _a1 error) *SyncAgentService_ExecuteTaskSyncClient_Recv

+ type SyncAgentService_ExecuteTaskSyncClient_RecvMsg struct

+ func (_m SyncAgentService_ExecuteTaskSyncClient_RecvMsg) Return(_a0 error) *SyncAgentService_ExecuteTaskSyncClient_RecvMsg

+ type SyncAgentService_ExecuteTaskSyncClient_Send struct

+ func (_m SyncAgentService_ExecuteTaskSyncClient_Send) Return(_a0 error) *SyncAgentService_ExecuteTaskSyncClient_Send

+ type SyncAgentService_ExecuteTaskSyncClient_SendMsg struct

+ func (_m SyncAgentService_ExecuteTaskSyncClient_SendMsg) Return(_a0 error) *SyncAgentService_ExecuteTaskSyncClient_SendMsg

+ type SyncAgentService_ExecuteTaskSyncClient_Trailer struct

+ func (_m SyncAgentService_ExecuteTaskSyncClient_Trailer) Return(_a0 metadata.MD) *SyncAgentService_ExecuteTaskSyncClient_Trailer

+ type SyncAgentService_ExecuteTaskSyncServer struct

+ func (_m *SyncAgentService_ExecuteTaskSyncServer) Context() context.Context

+ func (_m *SyncAgentService_ExecuteTaskSyncServer) OnContext() *SyncAgentService_ExecuteTaskSyncServer_Context

+ func (_m *SyncAgentService_ExecuteTaskSyncServer) OnContextMatch(matchers ...interface{}) *SyncAgentService_ExecuteTaskSyncServer_Context

+ func (_m *SyncAgentService_ExecuteTaskSyncServer) OnRecv() *SyncAgentService_ExecuteTaskSyncServer_Recv

+ func (_m *SyncAgentService_ExecuteTaskSyncServer) OnRecvMatch(matchers ...interface{}) *SyncAgentService_ExecuteTaskSyncServer_Recv

+ func (_m *SyncAgentService_ExecuteTaskSyncServer) OnRecvMsg(m interface{}) *SyncAgentService_ExecuteTaskSyncServer_RecvMsg

+ func (_m *SyncAgentService_ExecuteTaskSyncServer) OnRecvMsgMatch(matchers ...interface{}) *SyncAgentService_ExecuteTaskSyncServer_RecvMsg

+ func (_m *SyncAgentService_ExecuteTaskSyncServer) OnSend(_a0 *admin.ExecuteTaskSyncResponse) *SyncAgentService_ExecuteTaskSyncServer_Send

+ func (_m *SyncAgentService_ExecuteTaskSyncServer) OnSendHeader(_a0 metadata.MD) *SyncAgentService_ExecuteTaskSyncServer_SendHeader

+ func (_m *SyncAgentService_ExecuteTaskSyncServer) OnSendHeaderMatch(matchers ...interface{}) *SyncAgentService_ExecuteTaskSyncServer_SendHeader

+ func (_m *SyncAgentService_ExecuteTaskSyncServer) OnSendMatch(matchers ...interface{}) *SyncAgentService_ExecuteTaskSyncServer_Send

+ func (_m *SyncAgentService_ExecuteTaskSyncServer) OnSendMsg(m interface{}) *SyncAgentService_ExecuteTaskSyncServer_SendMsg

+ func (_m *SyncAgentService_ExecuteTaskSyncServer) OnSendMsgMatch(matchers ...interface{}) *SyncAgentService_ExecuteTaskSyncServer_SendMsg

+ func (_m *SyncAgentService_ExecuteTaskSyncServer) OnSetHeader(_a0 metadata.MD) *SyncAgentService_ExecuteTaskSyncServer_SetHeader

+ func (_m *SyncAgentService_ExecuteTaskSyncServer) OnSetHeaderMatch(matchers ...interface{}) *SyncAgentService_ExecuteTaskSyncServer_SetHeader

+ func (_m *SyncAgentService_ExecuteTaskSyncServer) Recv() (*admin.ExecuteTaskSyncRequest, error)

+ func (_m *SyncAgentService_ExecuteTaskSyncServer) RecvMsg(m interface{}) error

+ func (_m *SyncAgentService_ExecuteTaskSyncServer) Send(_a0 *admin.ExecuteTaskSyncResponse) error

+ func (_m *SyncAgentService_ExecuteTaskSyncServer) SendHeader(_a0 metadata.MD) error

+ func (_m *SyncAgentService_ExecuteTaskSyncServer) SendMsg(m interface{}) error

+ func (_m *SyncAgentService_ExecuteTaskSyncServer) SetHeader(_a0 metadata.MD) error

+ func (_m *SyncAgentService_ExecuteTaskSyncServer) SetTrailer(_a0 metadata.MD)

+ type SyncAgentService_ExecuteTaskSyncServer_Context struct

+ func (_m SyncAgentService_ExecuteTaskSyncServer_Context) Return(_a0 context.Context) *SyncAgentService_ExecuteTaskSyncServer_Context

+ type SyncAgentService_ExecuteTaskSyncServer_Recv struct

+ func (_m SyncAgentService_ExecuteTaskSyncServer_Recv) Return(_a0 *admin.ExecuteTaskSyncRequest, _a1 error) *SyncAgentService_ExecuteTaskSyncServer_Recv

+ type SyncAgentService_ExecuteTaskSyncServer_RecvMsg struct

+ func (_m SyncAgentService_ExecuteTaskSyncServer_RecvMsg) Return(_a0 error) *SyncAgentService_ExecuteTaskSyncServer_RecvMsg

+ type SyncAgentService_ExecuteTaskSyncServer_Send struct

+ func (_m SyncAgentService_ExecuteTaskSyncServer_Send) Return(_a0 error) *SyncAgentService_ExecuteTaskSyncServer_Send

+ type SyncAgentService_ExecuteTaskSyncServer_SendHeader struct

+ func (_m SyncAgentService_ExecuteTaskSyncServer_SendHeader) Return(_a0 error) *SyncAgentService_ExecuteTaskSyncServer_SendHeader

+ type SyncAgentService_ExecuteTaskSyncServer_SendMsg struct

+ func (_m SyncAgentService_ExecuteTaskSyncServer_SendMsg) Return(_a0 error) *SyncAgentService_ExecuteTaskSyncServer_SendMsg

+ type SyncAgentService_ExecuteTaskSyncServer_SetHeader struct

+ func (_m SyncAgentService_ExecuteTaskSyncServer_SetHeader) Return(_a0 error) *SyncAgentService_ExecuteTaskSyncServer_SetHeader

+ type UnsafeSyncAgentServiceServer struct

v1.11.0-b1

Mar 5, 2024

v1.11.0-b0

Feb 29, 2024

v1.10.7

Feb 14, 2024

Changes in this version

type AdminServiceClient

+ func (_m *AdminServiceClient) GetDynamicNodeWorkflow(ctx context.Context, in *admin.GetDynamicNodeWorkflowRequest, ...) (*admin.DynamicNodeWorkflowResponse, error)

+ func (_m *AdminServiceClient) OnGetDynamicNodeWorkflow(ctx context.Context, in *admin.GetDynamicNodeWorkflowRequest, ...) *AdminServiceClient_GetDynamicNodeWorkflow

+ func (_m *AdminServiceClient) OnGetDynamicNodeWorkflowMatch(matchers ...interface{}) *AdminServiceClient_GetDynamicNodeWorkflow

+ type AdminServiceClient_GetDynamicNodeWorkflow struct

+ func (_m AdminServiceClient_GetDynamicNodeWorkflow) Return(_a0 *admin.DynamicNodeWorkflowResponse, _a1 error) *AdminServiceClient_GetDynamicNodeWorkflow

type AdminServiceServer

+ func (_m *AdminServiceServer) GetDynamicNodeWorkflow(_a0 context.Context, _a1 *admin.GetDynamicNodeWorkflowRequest) (*admin.DynamicNodeWorkflowResponse, error)

+ func (_m *AdminServiceServer) OnGetDynamicNodeWorkflow(_a0 context.Context, _a1 *admin.GetDynamicNodeWorkflowRequest) *AdminServiceServer_GetDynamicNodeWorkflow

+ func (_m *AdminServiceServer) OnGetDynamicNodeWorkflowMatch(matchers ...interface{}) *AdminServiceServer_GetDynamicNodeWorkflow

+ type AdminServiceServer_GetDynamicNodeWorkflow struct

+ func (_m AdminServiceServer_GetDynamicNodeWorkflow) Return(_a0 *admin.DynamicNodeWorkflowResponse, _a1 error) *AdminServiceServer_GetDynamicNodeWorkflow

+ type AgentMetadataServiceClient struct

+ func (_m *AgentMetadataServiceClient) GetAgent(ctx context.Context, in *admin.GetAgentRequest, opts ...grpc.CallOption) (*admin.GetAgentResponse, error)

+ func (_m *AgentMetadataServiceClient) ListAgents(ctx context.Context, in *admin.ListAgentsRequest, opts ...grpc.CallOption) (*admin.ListAgentsResponse, error)

+ func (_m *AgentMetadataServiceClient) OnGetAgent(ctx context.Context, in *admin.GetAgentRequest, opts ...grpc.CallOption) *AgentMetadataServiceClient_GetAgent

+ func (_m *AgentMetadataServiceClient) OnGetAgentMatch(matchers ...interface{}) *AgentMetadataServiceClient_GetAgent

+ func (_m *AgentMetadataServiceClient) OnListAgents(ctx context.Context, in *admin.ListAgentsRequest, opts ...grpc.CallOption) *AgentMetadataServiceClient_ListAgents

+ func (_m *AgentMetadataServiceClient) OnListAgentsMatch(matchers ...interface{}) *AgentMetadataServiceClient_ListAgents

+ type AgentMetadataServiceClient_GetAgent struct

+ func (_m AgentMetadataServiceClient_GetAgent) Return(_a0 *admin.GetAgentResponse, _a1 error) *AgentMetadataServiceClient_GetAgent

+ type AgentMetadataServiceClient_ListAgents struct

+ func (_m AgentMetadataServiceClient_ListAgents) Return(_a0 *admin.ListAgentsResponse, _a1 error) *AgentMetadataServiceClient_ListAgents

+ type AgentMetadataServiceServer struct

+ func (_m *AgentMetadataServiceServer) GetAgent(_a0 context.Context, _a1 *admin.GetAgentRequest) (*admin.GetAgentResponse, error)

+ func (_m *AgentMetadataServiceServer) ListAgents(_a0 context.Context, _a1 *admin.ListAgentsRequest) (*admin.ListAgentsResponse, error)

+ func (_m *AgentMetadataServiceServer) OnGetAgent(_a0 context.Context, _a1 *admin.GetAgentRequest) *AgentMetadataServiceServer_GetAgent

+ func (_m *AgentMetadataServiceServer) OnGetAgentMatch(matchers ...interface{}) *AgentMetadataServiceServer_GetAgent

+ func (_m *AgentMetadataServiceServer) OnListAgents(_a0 context.Context, _a1 *admin.ListAgentsRequest) *AgentMetadataServiceServer_ListAgents

+ func (_m *AgentMetadataServiceServer) OnListAgentsMatch(matchers ...interface{}) *AgentMetadataServiceServer_ListAgents

+ type AgentMetadataServiceServer_GetAgent struct

+ func (_m AgentMetadataServiceServer_GetAgent) Return(_a0 *admin.GetAgentResponse, _a1 error) *AgentMetadataServiceServer_GetAgent

+ type AgentMetadataServiceServer_ListAgents struct

+ func (_m AgentMetadataServiceServer_ListAgents) Return(_a0 *admin.ListAgentsResponse, _a1 error) *AgentMetadataServiceServer_ListAgents

type AsyncAgentServiceClient

+ func (_m *AsyncAgentServiceClient) GetTaskLogs(ctx context.Context, in *admin.GetTaskLogsRequest, opts ...grpc.CallOption) (*admin.GetTaskLogsResponse, error)

+ func (_m *AsyncAgentServiceClient) GetTaskMetrics(ctx context.Context, in *admin.GetTaskMetricsRequest, opts ...grpc.CallOption) (*admin.GetTaskMetricsResponse, error)

+ func (_m *AsyncAgentServiceClient) OnGetTaskLogs(ctx context.Context, in *admin.GetTaskLogsRequest, opts ...grpc.CallOption) *AsyncAgentServiceClient_GetTaskLogs

+ func (_m *AsyncAgentServiceClient) OnGetTaskLogsMatch(matchers ...interface{}) *AsyncAgentServiceClient_GetTaskLogs

+ func (_m *AsyncAgentServiceClient) OnGetTaskMetrics(ctx context.Context, in *admin.GetTaskMetricsRequest, opts ...grpc.CallOption) *AsyncAgentServiceClient_GetTaskMetrics

+ func (_m *AsyncAgentServiceClient) OnGetTaskMetricsMatch(matchers ...interface{}) *AsyncAgentServiceClient_GetTaskMetrics

+ type AsyncAgentServiceClient_GetTaskLogs struct

+ func (_m AsyncAgentServiceClient_GetTaskLogs) Return(_a0 *admin.GetTaskLogsResponse, _a1 error) *AsyncAgentServiceClient_GetTaskLogs

+ type AsyncAgentServiceClient_GetTaskMetrics struct

+ func (_m AsyncAgentServiceClient_GetTaskMetrics) Return(_a0 *admin.GetTaskMetricsResponse, _a1 error) *AsyncAgentServiceClient_GetTaskMetrics

type AsyncAgentServiceServer

+ func (_m *AsyncAgentServiceServer) GetTaskLogs(_a0 context.Context, _a1 *admin.GetTaskLogsRequest) (*admin.GetTaskLogsResponse, error)

+ func (_m *AsyncAgentServiceServer) GetTaskMetrics(_a0 context.Context, _a1 *admin.GetTaskMetricsRequest) (*admin.GetTaskMetricsResponse, error)

+ func (_m *AsyncAgentServiceServer) OnGetTaskLogs(_a0 context.Context, _a1 *admin.GetTaskLogsRequest) *AsyncAgentServiceServer_GetTaskLogs

+ func (_m *AsyncAgentServiceServer) OnGetTaskLogsMatch(matchers ...interface{}) *AsyncAgentServiceServer_GetTaskLogs

+ func (_m *AsyncAgentServiceServer) OnGetTaskMetrics(_a0 context.Context, _a1 *admin.GetTaskMetricsRequest) *AsyncAgentServiceServer_GetTaskMetrics

+ func (_m *AsyncAgentServiceServer) OnGetTaskMetricsMatch(matchers ...interface{}) *AsyncAgentServiceServer_GetTaskMetrics

+ type AsyncAgentServiceServer_GetTaskLogs struct

+ func (_m AsyncAgentServiceServer_GetTaskLogs) Return(_a0 *admin.GetTaskLogsResponse, _a1 error) *AsyncAgentServiceServer_GetTaskLogs

+ type AsyncAgentServiceServer_GetTaskMetrics struct

+ func (_m AsyncAgentServiceServer_GetTaskMetrics) Return(_a0 *admin.GetTaskMetricsResponse, _a1 error) *AsyncAgentServiceServer_GetTaskMetrics

+ type UnsafeAdminServiceServer struct

+ type UnsafeAgentMetadataServiceServer struct

+ type UnsafeAsyncAgentServiceServer struct

+ type UnsafeAuthMetadataServiceServer struct

+ type UnsafeDataProxyServiceServer struct

+ type UnsafeExternalPluginServiceServer struct

+ type UnsafeIdentityServiceServer struct

+ type UnsafeSignalServiceServer struct

v1.10.7-b4

Feb 6, 2024

v1.10.7-b3

Jan 31, 2024

v1.10.7-b2

Jan 23, 2024

v1.10.7-b1

Jan 18, 2024

v1.10.7-b0

Jan 8, 2024

v1.10.6

Dec 6, 2023

v1.10.6-b0

Nov 30, 2023

v1.10.5

Oct 26, 2023

v1.10.4

Oct 25, 2023

v1.10.3

Oct 24, 2023

v1.10.2

Oct 23, 2023

v1.10.1

Oct 21, 2023

v1.10.0

Oct 20, 2023

v1.9.37

Oct 20, 2023

v1.9.36

Oct 20, 2023

v1.9.35

Oct 20, 2023

v1.9.34

Oct 19, 2023

v1.9.33

Oct 19, 2023

v1.9.32

Oct 19, 2023

v1.9.31

Oct 19, 2023

v1.9.30

Oct 18, 2023

v1.9.29

Oct 18, 2023

v1.9.28

Oct 17, 2023

v1.9.27

Oct 16, 2023

v1.9.26

Oct 16, 2023

v1.9.25

Oct 16, 2023

v1.9.24

Oct 16, 2023

v1.9.23

Oct 16, 2023

v1.9.22

Oct 13, 2023

v1.9.21

Oct 12, 2023

v1.9.20

Oct 12, 2023

v1.9.19

Oct 12, 2023

v1.9.18

Oct 11, 2023

v1.9.17

Oct 11, 2023

v1.9.16

Oct 11, 2023

v1.9.15

Oct 10, 2023

v1.9.14

Oct 9, 2023

v1.9.13

Oct 6, 2023

v1.9.12

Oct 6, 2023

v1.9.11

Oct 5, 2023

v1.9.10

Oct 5, 2023

v1.9.9

Oct 5, 2023

v1.9.8

Oct 4, 2023

Changes in this version

+ type AdminServiceClient struct

+ func (_m *AdminServiceClient) CreateExecution(ctx context.Context, in *admin.ExecutionCreateRequest, opts ...grpc.CallOption) (*admin.ExecutionCreateResponse, error)

+ func (_m *AdminServiceClient) CreateLaunchPlan(ctx context.Context, in *admin.LaunchPlanCreateRequest, ...) (*admin.LaunchPlanCreateResponse, error)

+ func (_m *AdminServiceClient) CreateNodeEvent(ctx context.Context, in *admin.NodeExecutionEventRequest, ...) (*admin.NodeExecutionEventResponse, error)

+ func (_m *AdminServiceClient) CreateTask(ctx context.Context, in *admin.TaskCreateRequest, opts ...grpc.CallOption) (*admin.TaskCreateResponse, error)

+ func (_m *AdminServiceClient) CreateTaskEvent(ctx context.Context, in *admin.TaskExecutionEventRequest, ...) (*admin.TaskExecutionEventResponse, error)

+ func (_m *AdminServiceClient) CreateWorkflow(ctx context.Context, in *admin.WorkflowCreateRequest, opts ...grpc.CallOption) (*admin.WorkflowCreateResponse, error)

+ func (_m *AdminServiceClient) CreateWorkflowEvent(ctx context.Context, in *admin.WorkflowExecutionEventRequest, ...) (*admin.WorkflowExecutionEventResponse, error)

+ func (_m *AdminServiceClient) DeleteProjectAttributes(ctx context.Context, in *admin.ProjectAttributesDeleteRequest, ...) (*admin.ProjectAttributesDeleteResponse, error)

+ func (_m *AdminServiceClient) DeleteProjectDomainAttributes(ctx context.Context, in *admin.ProjectDomainAttributesDeleteRequest, ...) (*admin.ProjectDomainAttributesDeleteResponse, error)

+ func (_m *AdminServiceClient) DeleteWorkflowAttributes(ctx context.Context, in *admin.WorkflowAttributesDeleteRequest, ...) (*admin.WorkflowAttributesDeleteResponse, error)

+ func (_m *AdminServiceClient) GetActiveLaunchPlan(ctx context.Context, in *admin.ActiveLaunchPlanRequest, ...) (*admin.LaunchPlan, error)

+ func (_m *AdminServiceClient) GetDescriptionEntity(ctx context.Context, in *admin.ObjectGetRequest, opts ...grpc.CallOption) (*admin.DescriptionEntity, error)

+ func (_m *AdminServiceClient) GetExecution(ctx context.Context, in *admin.WorkflowExecutionGetRequest, ...) (*admin.Execution, error)

+ func (_m *AdminServiceClient) GetExecutionData(ctx context.Context, in *admin.WorkflowExecutionGetDataRequest, ...) (*admin.WorkflowExecutionGetDataResponse, error)

+ func (_m *AdminServiceClient) GetExecutionMetrics(ctx context.Context, in *admin.WorkflowExecutionGetMetricsRequest, ...) (*admin.WorkflowExecutionGetMetricsResponse, error)

+ func (_m *AdminServiceClient) GetLaunchPlan(ctx context.Context, in *admin.ObjectGetRequest, opts ...grpc.CallOption) (*admin.LaunchPlan, error)

+ func (_m *AdminServiceClient) GetNamedEntity(ctx context.Context, in *admin.NamedEntityGetRequest, opts ...grpc.CallOption) (*admin.NamedEntity, error)

+ func (_m *AdminServiceClient) GetNodeExecution(ctx context.Context, in *admin.NodeExecutionGetRequest, ...) (*admin.NodeExecution, error)

+ func (_m *AdminServiceClient) GetNodeExecutionData(ctx context.Context, in *admin.NodeExecutionGetDataRequest, ...) (*admin.NodeExecutionGetDataResponse, error)

+ func (_m *AdminServiceClient) GetProjectAttributes(ctx context.Context, in *admin.ProjectAttributesGetRequest, ...) (*admin.ProjectAttributesGetResponse, error)

+ func (_m *AdminServiceClient) GetProjectDomainAttributes(ctx context.Context, in *admin.ProjectDomainAttributesGetRequest, ...) (*admin.ProjectDomainAttributesGetResponse, error)

+ func (_m *AdminServiceClient) GetTask(ctx context.Context, in *admin.ObjectGetRequest, opts ...grpc.CallOption) (*admin.Task, error)

+ func (_m *AdminServiceClient) GetTaskExecution(ctx context.Context, in *admin.TaskExecutionGetRequest, ...) (*admin.TaskExecution, error)

+ func (_m *AdminServiceClient) GetTaskExecutionData(ctx context.Context, in *admin.TaskExecutionGetDataRequest, ...) (*admin.TaskExecutionGetDataResponse, error)

+ func (_m *AdminServiceClient) GetVersion(ctx context.Context, in *admin.GetVersionRequest, opts ...grpc.CallOption) (*admin.GetVersionResponse, error)

+ func (_m *AdminServiceClient) GetWorkflow(ctx context.Context, in *admin.ObjectGetRequest, opts ...grpc.CallOption) (*admin.Workflow, error)

+ func (_m *AdminServiceClient) GetWorkflowAttributes(ctx context.Context, in *admin.WorkflowAttributesGetRequest, ...) (*admin.WorkflowAttributesGetResponse, error)

+ func (_m *AdminServiceClient) ListActiveLaunchPlans(ctx context.Context, in *admin.ActiveLaunchPlanListRequest, ...) (*admin.LaunchPlanList, error)

+ func (_m *AdminServiceClient) ListDescriptionEntities(ctx context.Context, in *admin.DescriptionEntityListRequest, ...) (*admin.DescriptionEntityList, error)

+ func (_m *AdminServiceClient) ListExecutions(ctx context.Context, in *admin.ResourceListRequest, opts ...grpc.CallOption) (*admin.ExecutionList, error)

+ func (_m *AdminServiceClient) ListLaunchPlanIds(ctx context.Context, in *admin.NamedEntityIdentifierListRequest, ...) (*admin.NamedEntityIdentifierList, error)

+ func (_m *AdminServiceClient) ListLaunchPlans(ctx context.Context, in *admin.ResourceListRequest, opts ...grpc.CallOption) (*admin.LaunchPlanList, error)

+ func (_m *AdminServiceClient) ListMatchableAttributes(ctx context.Context, in *admin.ListMatchableAttributesRequest, ...) (*admin.ListMatchableAttributesResponse, error)

+ func (_m *AdminServiceClient) ListNamedEntities(ctx context.Context, in *admin.NamedEntityListRequest, opts ...grpc.CallOption) (*admin.NamedEntityList, error)

+ func (_m *AdminServiceClient) ListNodeExecutions(ctx context.Context, in *admin.NodeExecutionListRequest, ...) (*admin.NodeExecutionList, error)

+ func (_m *AdminServiceClient) ListNodeExecutionsForTask(ctx context.Context, in *admin.NodeExecutionForTaskListRequest, ...) (*admin.NodeExecutionList, error)

+ func (_m *AdminServiceClient) ListProjects(ctx context.Context, in *admin.ProjectListRequest, opts ...grpc.CallOption) (*admin.Projects, error)

+ func (_m *AdminServiceClient) ListTaskExecutions(ctx context.Context, in *admin.TaskExecutionListRequest, ...) (*admin.TaskExecutionList, error)

+ func (_m *AdminServiceClient) ListTaskIds(ctx context.Context, in *admin.NamedEntityIdentifierListRequest, ...) (*admin.NamedEntityIdentifierList, error)

+ func (_m *AdminServiceClient) ListTasks(ctx context.Context, in *admin.ResourceListRequest, opts ...grpc.CallOption) (*admin.TaskList, error)

+ func (_m *AdminServiceClient) ListWorkflowIds(ctx context.Context, in *admin.NamedEntityIdentifierListRequest, ...) (*admin.NamedEntityIdentifierList, error)

+ func (_m *AdminServiceClient) ListWorkflows(ctx context.Context, in *admin.ResourceListRequest, opts ...grpc.CallOption) (*admin.WorkflowList, error)

+ func (_m *AdminServiceClient) OnCreateExecution(ctx context.Context, in *admin.ExecutionCreateRequest, opts ...grpc.CallOption) *AdminServiceClient_CreateExecution

+ func (_m *AdminServiceClient) OnCreateExecutionMatch(matchers ...interface{}) *AdminServiceClient_CreateExecution

+ func (_m *AdminServiceClient) OnCreateLaunchPlan(ctx context.Context, in *admin.LaunchPlanCreateRequest, ...) *AdminServiceClient_CreateLaunchPlan

+ func (_m *AdminServiceClient) OnCreateLaunchPlanMatch(matchers ...interface{}) *AdminServiceClient_CreateLaunchPlan

+ func (_m *AdminServiceClient) OnCreateNodeEvent(ctx context.Context, in *admin.NodeExecutionEventRequest, ...) *AdminServiceClient_CreateNodeEvent

+ func (_m *AdminServiceClient) OnCreateNodeEventMatch(matchers ...interface{}) *AdminServiceClient_CreateNodeEvent

+ func (_m *AdminServiceClient) OnCreateTask(ctx context.Context, in *admin.TaskCreateRequest, opts ...grpc.CallOption) *AdminServiceClient_CreateTask

+ func (_m *AdminServiceClient) OnCreateTaskEvent(ctx context.Context, in *admin.TaskExecutionEventRequest, ...) *AdminServiceClient_CreateTaskEvent

+ func (_m *AdminServiceClient) OnCreateTaskEventMatch(matchers ...interface{}) *AdminServiceClient_CreateTaskEvent

+ func (_m *AdminServiceClient) OnCreateTaskMatch(matchers ...interface{}) *AdminServiceClient_CreateTask

+ func (_m *AdminServiceClient) OnCreateWorkflow(ctx context.Context, in *admin.WorkflowCreateRequest, opts ...grpc.CallOption) *AdminServiceClient_CreateWorkflow

+ func (_m *AdminServiceClient) OnCreateWorkflowEvent(ctx context.Context, in *admin.WorkflowExecutionEventRequest, ...) *AdminServiceClient_CreateWorkflowEvent

+ func (_m *AdminServiceClient) OnCreateWorkflowEventMatch(matchers ...interface{}) *AdminServiceClient_CreateWorkflowEvent

+ func (_m *AdminServiceClient) OnCreateWorkflowMatch(matchers ...interface{}) *AdminServiceClient_CreateWorkflow

+ func (_m *AdminServiceClient) OnDeleteProjectAttributes(ctx context.Context, in *admin.ProjectAttributesDeleteRequest, ...) *AdminServiceClient_DeleteProjectAttributes

+ func (_m *AdminServiceClient) OnDeleteProjectAttributesMatch(matchers ...interface{}) *AdminServiceClient_DeleteProjectAttributes

+ func (_m *AdminServiceClient) OnDeleteProjectDomainAttributes(ctx context.Context, in *admin.ProjectDomainAttributesDeleteRequest, ...) *AdminServiceClient_DeleteProjectDomainAttributes

+ func (_m *AdminServiceClient) OnDeleteProjectDomainAttributesMatch(matchers ...interface{}) *AdminServiceClient_DeleteProjectDomainAttributes

+ func (_m *AdminServiceClient) OnDeleteWorkflowAttributes(ctx context.Context, in *admin.WorkflowAttributesDeleteRequest, ...) *AdminServiceClient_DeleteWorkflowAttributes

+ func (_m *AdminServiceClient) OnDeleteWorkflowAttributesMatch(matchers ...interface{}) *AdminServiceClient_DeleteWorkflowAttributes

+ func (_m *AdminServiceClient) OnGetActiveLaunchPlan(ctx context.Context, in *admin.ActiveLaunchPlanRequest, ...) *AdminServiceClient_GetActiveLaunchPlan

+ func (_m *AdminServiceClient) OnGetActiveLaunchPlanMatch(matchers ...interface{}) *AdminServiceClient_GetActiveLaunchPlan

+ func (_m *AdminServiceClient) OnGetDescriptionEntity(ctx context.Context, in *admin.ObjectGetRequest, opts ...grpc.CallOption) *AdminServiceClient_GetDescriptionEntity

+ func (_m *AdminServiceClient) OnGetDescriptionEntityMatch(matchers ...interface{}) *AdminServiceClient_GetDescriptionEntity

+ func (_m *AdminServiceClient) OnGetExecution(ctx context.Context, in *admin.WorkflowExecutionGetRequest, ...) *AdminServiceClient_GetExecution

+ func (_m *AdminServiceClient) OnGetExecutionData(ctx context.Context, in *admin.WorkflowExecutionGetDataRequest, ...) *AdminServiceClient_GetExecutionData

+ func (_m *AdminServiceClient) OnGetExecutionDataMatch(matchers ...interface{}) *AdminServiceClient_GetExecutionData

+ func (_m *AdminServiceClient) OnGetExecutionMatch(matchers ...interface{}) *AdminServiceClient_GetExecution

+ func (_m *AdminServiceClient) OnGetExecutionMetrics(ctx context.Context, in *admin.WorkflowExecutionGetMetricsRequest, ...) *AdminServiceClient_GetExecutionMetrics

+ func (_m *AdminServiceClient) OnGetExecutionMetricsMatch(matchers ...interface{}) *AdminServiceClient_GetExecutionMetrics

+ func (_m *AdminServiceClient) OnGetLaunchPlan(ctx context.Context, in *admin.ObjectGetRequest, opts ...grpc.CallOption) *AdminServiceClient_GetLaunchPlan

+ func (_m *AdminServiceClient) OnGetLaunchPlanMatch(matchers ...interface{}) *AdminServiceClient_GetLaunchPlan

+ func (_m *AdminServiceClient) OnGetNamedEntity(ctx context.Context, in *admin.NamedEntityGetRequest, opts ...grpc.CallOption) *AdminServiceClient_GetNamedEntity

+ func (_m *AdminServiceClient) OnGetNamedEntityMatch(matchers ...interface{}) *AdminServiceClient_GetNamedEntity

+ func (_m *AdminServiceClient) OnGetNodeExecution(ctx context.Context, in *admin.NodeExecutionGetRequest, ...) *AdminServiceClient_GetNodeExecution

+ func (_m *AdminServiceClient) OnGetNodeExecutionData(ctx context.Context, in *admin.NodeExecutionGetDataRequest, ...) *AdminServiceClient_GetNodeExecutionData

+ func (_m *AdminServiceClient) OnGetNodeExecutionDataMatch(matchers ...interface{}) *AdminServiceClient_GetNodeExecutionData

+ func (_m *AdminServiceClient) OnGetNodeExecutionMatch(matchers ...interface{}) *AdminServiceClient_GetNodeExecution

+ func (_m *AdminServiceClient) OnGetProjectAttributes(ctx context.Context, in *admin.ProjectAttributesGetRequest, ...) *AdminServiceClient_GetProjectAttributes

+ func (_m *AdminServiceClient) OnGetProjectAttributesMatch(matchers ...interface{}) *AdminServiceClient_GetProjectAttributes

+ func (_m *AdminServiceClient) OnGetProjectDomainAttributes(ctx context.Context, in *admin.ProjectDomainAttributesGetRequest, ...) *AdminServiceClient_GetProjectDomainAttributes

+ func (_m *AdminServiceClient) OnGetProjectDomainAttributesMatch(matchers ...interface{}) *AdminServiceClient_GetProjectDomainAttributes

+ func (_m *AdminServiceClient) OnGetTask(ctx context.Context, in *admin.ObjectGetRequest, opts ...grpc.CallOption) *AdminServiceClient_GetTask

+ func (_m *AdminServiceClient) OnGetTaskExecution(ctx context.Context, in *admin.TaskExecutionGetRequest, ...) *AdminServiceClient_GetTaskExecution

+ func (_m *AdminServiceClient) OnGetTaskExecutionData(ctx context.Context, in *admin.TaskExecutionGetDataRequest, ...) *AdminServiceClient_GetTaskExecutionData

+ func (_m *AdminServiceClient) OnGetTaskExecutionDataMatch(matchers ...interface{}) *AdminServiceClient_GetTaskExecutionData

+ func (_m *AdminServiceClient) OnGetTaskExecutionMatch(matchers ...interface{}) *AdminServiceClient_GetTaskExecution

+ func (_m *AdminServiceClient) OnGetTaskMatch(matchers ...interface{}) *AdminServiceClient_GetTask

+ func (_m *AdminServiceClient) OnGetVersion(ctx context.Context, in *admin.GetVersionRequest, opts ...grpc.CallOption) *AdminServiceClient_GetVersion

+ func (_m *AdminServiceClient) OnGetVersionMatch(matchers ...interface{}) *AdminServiceClient_GetVersion

+ func (_m *AdminServiceClient) OnGetWorkflow(ctx context.Context, in *admin.ObjectGetRequest, opts ...grpc.CallOption) *AdminServiceClient_GetWorkflow

+ func (_m *AdminServiceClient) OnGetWorkflowAttributes(ctx context.Context, in *admin.WorkflowAttributesGetRequest, ...) *AdminServiceClient_GetWorkflowAttributes

+ func (_m *AdminServiceClient) OnGetWorkflowAttributesMatch(matchers ...interface{}) *AdminServiceClient_GetWorkflowAttributes

+ func (_m *AdminServiceClient) OnGetWorkflowMatch(matchers ...interface{}) *AdminServiceClient_GetWorkflow

+ func (_m *AdminServiceClient) OnListActiveLaunchPlans(ctx context.Context, in *admin.ActiveLaunchPlanListRequest, ...) *AdminServiceClient_ListActiveLaunchPlans

+ func (_m *AdminServiceClient) OnListActiveLaunchPlansMatch(matchers ...interface{}) *AdminServiceClient_ListActiveLaunchPlans

+ func (_m *AdminServiceClient) OnListDescriptionEntities(ctx context.Context, in *admin.DescriptionEntityListRequest, ...) *AdminServiceClient_ListDescriptionEntities

+ func (_m *AdminServiceClient) OnListDescriptionEntitiesMatch(matchers ...interface{}) *AdminServiceClient_ListDescriptionEntities

+ func (_m *AdminServiceClient) OnListExecutions(ctx context.Context, in *admin.ResourceListRequest, opts ...grpc.CallOption) *AdminServiceClient_ListExecutions

+ func (_m *AdminServiceClient) OnListExecutionsMatch(matchers ...interface{}) *AdminServiceClient_ListExecutions

+ func (_m *AdminServiceClient) OnListLaunchPlanIds(ctx context.Context, in *admin.NamedEntityIdentifierListRequest, ...) *AdminServiceClient_ListLaunchPlanIds

+ func (_m *AdminServiceClient) OnListLaunchPlanIdsMatch(matchers ...interface{}) *AdminServiceClient_ListLaunchPlanIds

+ func (_m *AdminServiceClient) OnListLaunchPlans(ctx context.Context, in *admin.ResourceListRequest, opts ...grpc.CallOption) *AdminServiceClient_ListLaunchPlans

+ func (_m *AdminServiceClient) OnListLaunchPlansMatch(matchers ...interface{}) *AdminServiceClient_ListLaunchPlans

+ func (_m *AdminServiceClient) OnListMatchableAttributes(ctx context.Context, in *admin.ListMatchableAttributesRequest, ...) *AdminServiceClient_ListMatchableAttributes

+ func (_m *AdminServiceClient) OnListMatchableAttributesMatch(matchers ...interface{}) *AdminServiceClient_ListMatchableAttributes

+ func (_m *AdminServiceClient) OnListNamedEntities(ctx context.Context, in *admin.NamedEntityListRequest, opts ...grpc.CallOption) *AdminServiceClient_ListNamedEntities

+ func (_m *AdminServiceClient) OnListNamedEntitiesMatch(matchers ...interface{}) *AdminServiceClient_ListNamedEntities

+ func (_m *AdminServiceClient) OnListNodeExecutions(ctx context.Context, in *admin.NodeExecutionListRequest, ...) *AdminServiceClient_ListNodeExecutions

+ func (_m *AdminServiceClient) OnListNodeExecutionsForTask(ctx context.Context, in *admin.NodeExecutionForTaskListRequest, ...) *AdminServiceClient_ListNodeExecutionsForTask

+ func (_m *AdminServiceClient) OnListNodeExecutionsForTaskMatch(matchers ...interface{}) *AdminServiceClient_ListNodeExecutionsForTask

+ func (_m *AdminServiceClient) OnListNodeExecutionsMatch(matchers ...interface{}) *AdminServiceClient_ListNodeExecutions

+ func (_m *AdminServiceClient) OnListProjects(ctx context.Context, in *admin.ProjectListRequest, opts ...grpc.CallOption) *AdminServiceClient_ListProjects

+ func (_m *AdminServiceClient) OnListProjectsMatch(matchers ...interface{}) *AdminServiceClient_ListProjects

+ func (_m *AdminServiceClient) OnListTaskExecutions(ctx context.Context, in *admin.TaskExecutionListRequest, ...) *AdminServiceClient_ListTaskExecutions

+ func (_m *AdminServiceClient) OnListTaskExecutionsMatch(matchers ...interface{}) *AdminServiceClient_ListTaskExecutions

+ func (_m *AdminServiceClient) OnListTaskIds(ctx context.Context, in *admin.NamedEntityIdentifierListRequest, ...) *AdminServiceClient_ListTaskIds

+ func (_m *AdminServiceClient) OnListTaskIdsMatch(matchers ...interface{}) *AdminServiceClient_ListTaskIds

+ func (_m *AdminServiceClient) OnListTasks(ctx context.Context, in *admin.ResourceListRequest, opts ...grpc.CallOption) *AdminServiceClient_ListTasks

+ func (_m *AdminServiceClient) OnListTasksMatch(matchers ...interface{}) *AdminServiceClient_ListTasks

+ func (_m *AdminServiceClient) OnListWorkflowIds(ctx context.Context, in *admin.NamedEntityIdentifierListRequest, ...) *AdminServiceClient_ListWorkflowIds

+ func (_m *AdminServiceClient) OnListWorkflowIdsMatch(matchers ...interface{}) *AdminServiceClient_ListWorkflowIds

+ func (_m *AdminServiceClient) OnListWorkflows(ctx context.Context, in *admin.ResourceListRequest, opts ...grpc.CallOption) *AdminServiceClient_ListWorkflows

+ func (_m *AdminServiceClient) OnListWorkflowsMatch(matchers ...interface{}) *AdminServiceClient_ListWorkflows

+ func (_m *AdminServiceClient) OnRecoverExecution(ctx context.Context, in *admin.ExecutionRecoverRequest, ...) *AdminServiceClient_RecoverExecution

+ func (_m *AdminServiceClient) OnRecoverExecutionMatch(matchers ...interface{}) *AdminServiceClient_RecoverExecution

+ func (_m *AdminServiceClient) OnRegisterProject(ctx context.Context, in *admin.ProjectRegisterRequest, opts ...grpc.CallOption) *AdminServiceClient_RegisterProject

+ func (_m *AdminServiceClient) OnRegisterProjectMatch(matchers ...interface{}) *AdminServiceClient_RegisterProject

+ func (_m *AdminServiceClient) OnRelaunchExecution(ctx context.Context, in *admin.ExecutionRelaunchRequest, ...) *AdminServiceClient_RelaunchExecution

+ func (_m *AdminServiceClient) OnRelaunchExecutionMatch(matchers ...interface{}) *AdminServiceClient_RelaunchExecution

+ func (_m *AdminServiceClient) OnTerminateExecution(ctx context.Context, in *admin.ExecutionTerminateRequest, ...) *AdminServiceClient_TerminateExecution

+ func (_m *AdminServiceClient) OnTerminateExecutionMatch(matchers ...interface{}) *AdminServiceClient_TerminateExecution

+ func (_m *AdminServiceClient) OnUpdateExecution(ctx context.Context, in *admin.ExecutionUpdateRequest, opts ...grpc.CallOption) *AdminServiceClient_UpdateExecution

+ func (_m *AdminServiceClient) OnUpdateExecutionMatch(matchers ...interface{}) *AdminServiceClient_UpdateExecution

+ func (_m *AdminServiceClient) OnUpdateLaunchPlan(ctx context.Context, in *admin.LaunchPlanUpdateRequest, ...) *AdminServiceClient_UpdateLaunchPlan

+ func (_m *AdminServiceClient) OnUpdateLaunchPlanMatch(matchers ...interface{}) *AdminServiceClient_UpdateLaunchPlan

+ func (_m *AdminServiceClient) OnUpdateNamedEntity(ctx context.Context, in *admin.NamedEntityUpdateRequest, ...) *AdminServiceClient_UpdateNamedEntity

+ func (_m *AdminServiceClient) OnUpdateNamedEntityMatch(matchers ...interface{}) *AdminServiceClient_UpdateNamedEntity

+ func (_m *AdminServiceClient) OnUpdateProject(ctx context.Context, in *admin.Project, opts ...grpc.CallOption) *AdminServiceClient_UpdateProject

+ func (_m *AdminServiceClient) OnUpdateProjectAttributes(ctx context.Context, in *admin.ProjectAttributesUpdateRequest, ...) *AdminServiceClient_UpdateProjectAttributes

+ func (_m *AdminServiceClient) OnUpdateProjectAttributesMatch(matchers ...interface{}) *AdminServiceClient_UpdateProjectAttributes

+ func (_m *AdminServiceClient) OnUpdateProjectDomainAttributes(ctx context.Context, in *admin.ProjectDomainAttributesUpdateRequest, ...) *AdminServiceClient_UpdateProjectDomainAttributes

+ func (_m *AdminServiceClient) OnUpdateProjectDomainAttributesMatch(matchers ...interface{}) *AdminServiceClient_UpdateProjectDomainAttributes

+ func (_m *AdminServiceClient) OnUpdateProjectMatch(matchers ...interface{}) *AdminServiceClient_UpdateProject

+ func (_m *AdminServiceClient) OnUpdateWorkflowAttributes(ctx context.Context, in *admin.WorkflowAttributesUpdateRequest, ...) *AdminServiceClient_UpdateWorkflowAttributes

+ func (_m *AdminServiceClient) OnUpdateWorkflowAttributesMatch(matchers ...interface{}) *AdminServiceClient_UpdateWorkflowAttributes

+ func (_m *AdminServiceClient) RecoverExecution(ctx context.Context, in *admin.ExecutionRecoverRequest, ...) (*admin.ExecutionCreateResponse, error)

+ func (_m *AdminServiceClient) RegisterProject(ctx context.Context, in *admin.ProjectRegisterRequest, opts ...grpc.CallOption) (*admin.ProjectRegisterResponse, error)

+ func (_m *AdminServiceClient) RelaunchExecution(ctx context.Context, in *admin.ExecutionRelaunchRequest, ...) (*admin.ExecutionCreateResponse, error)

+ func (_m *AdminServiceClient) TerminateExecution(ctx context.Context, in *admin.ExecutionTerminateRequest, ...) (*admin.ExecutionTerminateResponse, error)

+ func (_m *AdminServiceClient) UpdateExecution(ctx context.Context, in *admin.ExecutionUpdateRequest, opts ...grpc.CallOption) (*admin.ExecutionUpdateResponse, error)

+ func (_m *AdminServiceClient) UpdateLaunchPlan(ctx context.Context, in *admin.LaunchPlanUpdateRequest, ...) (*admin.LaunchPlanUpdateResponse, error)

+ func (_m *AdminServiceClient) UpdateNamedEntity(ctx context.Context, in *admin.NamedEntityUpdateRequest, ...) (*admin.NamedEntityUpdateResponse, error)

+ func (_m *AdminServiceClient) UpdateProject(ctx context.Context, in *admin.Project, opts ...grpc.CallOption) (*admin.ProjectUpdateResponse, error)

+ func (_m *AdminServiceClient) UpdateProjectAttributes(ctx context.Context, in *admin.ProjectAttributesUpdateRequest, ...) (*admin.ProjectAttributesUpdateResponse, error)

+ func (_m *AdminServiceClient) UpdateProjectDomainAttributes(ctx context.Context, in *admin.ProjectDomainAttributesUpdateRequest, ...) (*admin.ProjectDomainAttributesUpdateResponse, error)

+ func (_m *AdminServiceClient) UpdateWorkflowAttributes(ctx context.Context, in *admin.WorkflowAttributesUpdateRequest, ...) (*admin.WorkflowAttributesUpdateResponse, error)

+ type AdminServiceClient_CreateExecution struct

+ func (_m AdminServiceClient_CreateExecution) Return(_a0 *admin.ExecutionCreateResponse, _a1 error) *AdminServiceClient_CreateExecution

+ type AdminServiceClient_CreateLaunchPlan struct

+ func (_m AdminServiceClient_CreateLaunchPlan) Return(_a0 *admin.LaunchPlanCreateResponse, _a1 error) *AdminServiceClient_CreateLaunchPlan

+ type AdminServiceClient_CreateNodeEvent struct

+ func (_m AdminServiceClient_CreateNodeEvent) Return(_a0 *admin.NodeExecutionEventResponse, _a1 error) *AdminServiceClient_CreateNodeEvent

+ type AdminServiceClient_CreateTask struct

+ func (_m AdminServiceClient_CreateTask) Return(_a0 *admin.TaskCreateResponse, _a1 error) *AdminServiceClient_CreateTask

+ type AdminServiceClient_CreateTaskEvent struct

+ func (_m AdminServiceClient_CreateTaskEvent) Return(_a0 *admin.TaskExecutionEventResponse, _a1 error) *AdminServiceClient_CreateTaskEvent

+ type AdminServiceClient_CreateWorkflow struct

+ func (_m AdminServiceClient_CreateWorkflow) Return(_a0 *admin.WorkflowCreateResponse, _a1 error) *AdminServiceClient_CreateWorkflow

+ type AdminServiceClient_CreateWorkflowEvent struct

+ func (_m AdminServiceClient_CreateWorkflowEvent) Return(_a0 *admin.WorkflowExecutionEventResponse, _a1 error) *AdminServiceClient_CreateWorkflowEvent

+ type AdminServiceClient_DeleteProjectAttributes struct

+ func (_m AdminServiceClient_DeleteProjectAttributes) Return(_a0 *admin.ProjectAttributesDeleteResponse, _a1 error) *AdminServiceClient_DeleteProjectAttributes

+ type AdminServiceClient_DeleteProjectDomainAttributes struct

+ func (_m AdminServiceClient_DeleteProjectDomainAttributes) Return(_a0 *admin.ProjectDomainAttributesDeleteResponse, _a1 error) *AdminServiceClient_DeleteProjectDomainAttributes

+ type AdminServiceClient_DeleteWorkflowAttributes struct

+ func (_m AdminServiceClient_DeleteWorkflowAttributes) Return(_a0 *admin.WorkflowAttributesDeleteResponse, _a1 error) *AdminServiceClient_DeleteWorkflowAttributes

+ type AdminServiceClient_GetActiveLaunchPlan struct

+ func (_m AdminServiceClient_GetActiveLaunchPlan) Return(_a0 *admin.LaunchPlan, _a1 error) *AdminServiceClient_GetActiveLaunchPlan

+ type AdminServiceClient_GetDescriptionEntity struct

+ func (_m AdminServiceClient_GetDescriptionEntity) Return(_a0 *admin.DescriptionEntity, _a1 error) *AdminServiceClient_GetDescriptionEntity

+ type AdminServiceClient_GetExecution struct

+ func (_m AdminServiceClient_GetExecution) Return(_a0 *admin.Execution, _a1 error) *AdminServiceClient_GetExecution

+ type AdminServiceClient_GetExecutionData struct

+ func (_m AdminServiceClient_GetExecutionData) Return(_a0 *admin.WorkflowExecutionGetDataResponse, _a1 error) *AdminServiceClient_GetExecutionData

+ type AdminServiceClient_GetExecutionMetrics struct

+ func (_m AdminServiceClient_GetExecutionMetrics) Return(_a0 *admin.WorkflowExecutionGetMetricsResponse, _a1 error) *AdminServiceClient_GetExecutionMetrics

+ type AdminServiceClient_GetLaunchPlan struct

+ func (_m AdminServiceClient_GetLaunchPlan) Return(_a0 *admin.LaunchPlan, _a1 error) *AdminServiceClient_GetLaunchPlan

+ type AdminServiceClient_GetNamedEntity struct

+ func (_m AdminServiceClient_GetNamedEntity) Return(_a0 *admin.NamedEntity, _a1 error) *AdminServiceClient_GetNamedEntity

+ type AdminServiceClient_GetNodeExecution struct

+ func (_m AdminServiceClient_GetNodeExecution) Return(_a0 *admin.NodeExecution, _a1 error) *AdminServiceClient_GetNodeExecution

+ type AdminServiceClient_GetNodeExecutionData struct

+ func (_m AdminServiceClient_GetNodeExecutionData) Return(_a0 *admin.NodeExecutionGetDataResponse, _a1 error) *AdminServiceClient_GetNodeExecutionData

+ type AdminServiceClient_GetProjectAttributes struct

+ func (_m AdminServiceClient_GetProjectAttributes) Return(_a0 *admin.ProjectAttributesGetResponse, _a1 error) *AdminServiceClient_GetProjectAttributes

+ type AdminServiceClient_GetProjectDomainAttributes struct

+ func (_m AdminServiceClient_GetProjectDomainAttributes) Return(_a0 *admin.ProjectDomainAttributesGetResponse, _a1 error) *AdminServiceClient_GetProjectDomainAttributes

+ type AdminServiceClient_GetTask struct

+ func (_m AdminServiceClient_GetTask) Return(_a0 *admin.Task, _a1 error) *AdminServiceClient_GetTask

+ type AdminServiceClient_GetTaskExecution struct

+ func (_m AdminServiceClient_GetTaskExecution) Return(_a0 *admin.TaskExecution, _a1 error) *AdminServiceClient_GetTaskExecution

+ type AdminServiceClient_GetTaskExecutionData struct

+ func (_m AdminServiceClient_GetTaskExecutionData) Return(_a0 *admin.TaskExecutionGetDataResponse, _a1 error) *AdminServiceClient_GetTaskExecutionData

+ type AdminServiceClient_GetVersion struct

+ func (_m AdminServiceClient_GetVersion) Return(_a0 *admin.GetVersionResponse, _a1 error) *AdminServiceClient_GetVersion

+ type AdminServiceClient_GetWorkflow struct

+ func (_m AdminServiceClient_GetWorkflow) Return(_a0 *admin.Workflow, _a1 error) *AdminServiceClient_GetWorkflow

+ type AdminServiceClient_GetWorkflowAttributes struct

+ func (_m AdminServiceClient_GetWorkflowAttributes) Return(_a0 *admin.WorkflowAttributesGetResponse, _a1 error) *AdminServiceClient_GetWorkflowAttributes

+ type AdminServiceClient_ListActiveLaunchPlans struct

+ func (_m AdminServiceClient_ListActiveLaunchPlans) Return(_a0 *admin.LaunchPlanList, _a1 error) *AdminServiceClient_ListActiveLaunchPlans

+ type AdminServiceClient_ListDescriptionEntities struct

+ func (_m AdminServiceClient_ListDescriptionEntities) Return(_a0 *admin.DescriptionEntityList, _a1 error) *AdminServiceClient_ListDescriptionEntities

+ type AdminServiceClient_ListExecutions struct

+ func (_m AdminServiceClient_ListExecutions) Return(_a0 *admin.ExecutionList, _a1 error) *AdminServiceClient_ListExecutions

+ type AdminServiceClient_ListLaunchPlanIds struct

+ func (_m AdminServiceClient_ListLaunchPlanIds) Return(_a0 *admin.NamedEntityIdentifierList, _a1 error) *AdminServiceClient_ListLaunchPlanIds

+ type AdminServiceClient_ListLaunchPlans struct

+ func (_m AdminServiceClient_ListLaunchPlans) Return(_a0 *admin.LaunchPlanList, _a1 error) *AdminServiceClient_ListLaunchPlans

+ type AdminServiceClient_ListMatchableAttributes struct

+ func (_m AdminServiceClient_ListMatchableAttributes) Return(_a0 *admin.ListMatchableAttributesResponse, _a1 error) *AdminServiceClient_ListMatchableAttributes

+ type AdminServiceClient_ListNamedEntities struct

+ func (_m AdminServiceClient_ListNamedEntities) Return(_a0 *admin.NamedEntityList, _a1 error) *AdminServiceClient_ListNamedEntities

+ type AdminServiceClient_ListNodeExecutions struct

+ func (_m AdminServiceClient_ListNodeExecutions) Return(_a0 *admin.NodeExecutionList, _a1 error) *AdminServiceClient_ListNodeExecutions

+ type AdminServiceClient_ListNodeExecutionsForTask struct

+ func (_m AdminServiceClient_ListNodeExecutionsForTask) Return(_a0 *admin.NodeExecutionList, _a1 error) *AdminServiceClient_ListNodeExecutionsForTask

+ type AdminServiceClient_ListProjects struct

+ func (_m AdminServiceClient_ListProjects) Return(_a0 *admin.Projects, _a1 error) *AdminServiceClient_ListProjects

+ type AdminServiceClient_ListTaskExecutions struct

+ func (_m AdminServiceClient_ListTaskExecutions) Return(_a0 *admin.TaskExecutionList, _a1 error) *AdminServiceClient_ListTaskExecutions

+ type AdminServiceClient_ListTaskIds struct

+ func (_m AdminServiceClient_ListTaskIds) Return(_a0 *admin.NamedEntityIdentifierList, _a1 error) *AdminServiceClient_ListTaskIds

+ type AdminServiceClient_ListTasks struct

+ func (_m AdminServiceClient_ListTasks) Return(_a0 *admin.TaskList, _a1 error) *AdminServiceClient_ListTasks

+ type AdminServiceClient_ListWorkflowIds struct

+ func (_m AdminServiceClient_ListWorkflowIds) Return(_a0 *admin.NamedEntityIdentifierList, _a1 error) *AdminServiceClient_ListWorkflowIds

+ type AdminServiceClient_ListWorkflows struct

+ func (_m AdminServiceClient_ListWorkflows) Return(_a0 *admin.WorkflowList, _a1 error) *AdminServiceClient_ListWorkflows

+ type AdminServiceClient_RecoverExecution struct

+ func (_m AdminServiceClient_RecoverExecution) Return(_a0 *admin.ExecutionCreateResponse, _a1 error) *AdminServiceClient_RecoverExecution

+ type AdminServiceClient_RegisterProject struct

+ func (_m AdminServiceClient_RegisterProject) Return(_a0 *admin.ProjectRegisterResponse, _a1 error) *AdminServiceClient_RegisterProject

+ type AdminServiceClient_RelaunchExecution struct

+ func (_m AdminServiceClient_RelaunchExecution) Return(_a0 *admin.ExecutionCreateResponse, _a1 error) *AdminServiceClient_RelaunchExecution

+ type AdminServiceClient_TerminateExecution struct

+ func (_m AdminServiceClient_TerminateExecution) Return(_a0 *admin.ExecutionTerminateResponse, _a1 error) *AdminServiceClient_TerminateExecution

+ type AdminServiceClient_UpdateExecution struct

+ func (_m AdminServiceClient_UpdateExecution) Return(_a0 *admin.ExecutionUpdateResponse, _a1 error) *AdminServiceClient_UpdateExecution

+ type AdminServiceClient_UpdateLaunchPlan struct

+ func (_m AdminServiceClient_UpdateLaunchPlan) Return(_a0 *admin.LaunchPlanUpdateResponse, _a1 error) *AdminServiceClient_UpdateLaunchPlan

+ type AdminServiceClient_UpdateNamedEntity struct

+ func (_m AdminServiceClient_UpdateNamedEntity) Return(_a0 *admin.NamedEntityUpdateResponse, _a1 error) *AdminServiceClient_UpdateNamedEntity

+ type AdminServiceClient_UpdateProject struct

+ func (_m AdminServiceClient_UpdateProject) Return(_a0 *admin.ProjectUpdateResponse, _a1 error) *AdminServiceClient_UpdateProject

+ type AdminServiceClient_UpdateProjectAttributes struct

+ func (_m AdminServiceClient_UpdateProjectAttributes) Return(_a0 *admin.ProjectAttributesUpdateResponse, _a1 error) *AdminServiceClient_UpdateProjectAttributes

+ type AdminServiceClient_UpdateProjectDomainAttributes struct

+ func (_m AdminServiceClient_UpdateProjectDomainAttributes) Return(_a0 *admin.ProjectDomainAttributesUpdateResponse, _a1 error) *AdminServiceClient_UpdateProjectDomainAttributes

+ type AdminServiceClient_UpdateWorkflowAttributes struct

+ func (_m AdminServiceClient_UpdateWorkflowAttributes) Return(_a0 *admin.WorkflowAttributesUpdateResponse, _a1 error) *AdminServiceClient_UpdateWorkflowAttributes

+ type AdminServiceServer struct

+ func (_m *AdminServiceServer) CreateExecution(_a0 context.Context, _a1 *admin.ExecutionCreateRequest) (*admin.ExecutionCreateResponse, error)

+ func (_m *AdminServiceServer) CreateLaunchPlan(_a0 context.Context, _a1 *admin.LaunchPlanCreateRequest) (*admin.LaunchPlanCreateResponse, error)

+ func (_m *AdminServiceServer) CreateNodeEvent(_a0 context.Context, _a1 *admin.NodeExecutionEventRequest) (*admin.NodeExecutionEventResponse, error)

+ func (_m *AdminServiceServer) CreateTask(_a0 context.Context, _a1 *admin.TaskCreateRequest) (*admin.TaskCreateResponse, error)

+ func (_m *AdminServiceServer) CreateTaskEvent(_a0 context.Context, _a1 *admin.TaskExecutionEventRequest) (*admin.TaskExecutionEventResponse, error)

+ func (_m *AdminServiceServer) CreateWorkflow(_a0 context.Context, _a1 *admin.WorkflowCreateRequest) (*admin.WorkflowCreateResponse, error)

+ func (_m *AdminServiceServer) CreateWorkflowEvent(_a0 context.Context, _a1 *admin.WorkflowExecutionEventRequest) (*admin.WorkflowExecutionEventResponse, error)

+ func (_m *AdminServiceServer) DeleteProjectAttributes(_a0 context.Context, _a1 *admin.ProjectAttributesDeleteRequest) (*admin.ProjectAttributesDeleteResponse, error)

+ func (_m *AdminServiceServer) DeleteProjectDomainAttributes(_a0 context.Context, _a1 *admin.ProjectDomainAttributesDeleteRequest) (*admin.ProjectDomainAttributesDeleteResponse, error)

+ func (_m *AdminServiceServer) DeleteWorkflowAttributes(_a0 context.Context, _a1 *admin.WorkflowAttributesDeleteRequest) (*admin.WorkflowAttributesDeleteResponse, error)

+ func (_m *AdminServiceServer) GetActiveLaunchPlan(_a0 context.Context, _a1 *admin.ActiveLaunchPlanRequest) (*admin.LaunchPlan, error)

+ func (_m *AdminServiceServer) GetDescriptionEntity(_a0 context.Context, _a1 *admin.ObjectGetRequest) (*admin.DescriptionEntity, error)

+ func (_m *AdminServiceServer) GetExecution(_a0 context.Context, _a1 *admin.WorkflowExecutionGetRequest) (*admin.Execution, error)

+ func (_m *AdminServiceServer) GetExecutionData(_a0 context.Context, _a1 *admin.WorkflowExecutionGetDataRequest) (*admin.WorkflowExecutionGetDataResponse, error)

+ func (_m *AdminServiceServer) GetExecutionMetrics(_a0 context.Context, _a1 *admin.WorkflowExecutionGetMetricsRequest) (*admin.WorkflowExecutionGetMetricsResponse, error)

+ func (_m *AdminServiceServer) GetLaunchPlan(_a0 context.Context, _a1 *admin.ObjectGetRequest) (*admin.LaunchPlan, error)

+ func (_m *AdminServiceServer) GetNamedEntity(_a0 context.Context, _a1 *admin.NamedEntityGetRequest) (*admin.NamedEntity, error)

+ func (_m *AdminServiceServer) GetNodeExecution(_a0 context.Context, _a1 *admin.NodeExecutionGetRequest) (*admin.NodeExecution, error)

+ func (_m *AdminServiceServer) GetNodeExecutionData(_a0 context.Context, _a1 *admin.NodeExecutionGetDataRequest) (*admin.NodeExecutionGetDataResponse, error)

+ func (_m *AdminServiceServer) GetProjectAttributes(_a0 context.Context, _a1 *admin.ProjectAttributesGetRequest) (*admin.ProjectAttributesGetResponse, error)

+ func (_m *AdminServiceServer) GetProjectDomainAttributes(_a0 context.Context, _a1 *admin.ProjectDomainAttributesGetRequest) (*admin.ProjectDomainAttributesGetResponse, error)

+ func (_m *AdminServiceServer) GetTask(_a0 context.Context, _a1 *admin.ObjectGetRequest) (*admin.Task, error)

+ func (_m *AdminServiceServer) GetTaskExecution(_a0 context.Context, _a1 *admin.TaskExecutionGetRequest) (*admin.TaskExecution, error)

+ func (_m *AdminServiceServer) GetTaskExecutionData(_a0 context.Context, _a1 *admin.TaskExecutionGetDataRequest) (*admin.TaskExecutionGetDataResponse, error)

+ func (_m *AdminServiceServer) GetVersion(_a0 context.Context, _a1 *admin.GetVersionRequest) (*admin.GetVersionResponse, error)

+ func (_m *AdminServiceServer) GetWorkflow(_a0 context.Context, _a1 *admin.ObjectGetRequest) (*admin.Workflow, error)

+ func (_m *AdminServiceServer) GetWorkflowAttributes(_a0 context.Context, _a1 *admin.WorkflowAttributesGetRequest) (*admin.WorkflowAttributesGetResponse, error)

+ func (_m *AdminServiceServer) ListActiveLaunchPlans(_a0 context.Context, _a1 *admin.ActiveLaunchPlanListRequest) (*admin.LaunchPlanList, error)

+ func (_m *AdminServiceServer) ListDescriptionEntities(_a0 context.Context, _a1 *admin.DescriptionEntityListRequest) (*admin.DescriptionEntityList, error)

+ func (_m *AdminServiceServer) ListExecutions(_a0 context.Context, _a1 *admin.ResourceListRequest) (*admin.ExecutionList, error)

+ func (_m *AdminServiceServer) ListLaunchPlanIds(_a0 context.Context, _a1 *admin.NamedEntityIdentifierListRequest) (*admin.NamedEntityIdentifierList, error)

+ func (_m *AdminServiceServer) ListLaunchPlans(_a0 context.Context, _a1 *admin.ResourceListRequest) (*admin.LaunchPlanList, error)

+ func (_m *AdminServiceServer) ListMatchableAttributes(_a0 context.Context, _a1 *admin.ListMatchableAttributesRequest) (*admin.ListMatchableAttributesResponse, error)

+ func (_m *AdminServiceServer) ListNamedEntities(_a0 context.Context, _a1 *admin.NamedEntityListRequest) (*admin.NamedEntityList, error)

+ func (_m *AdminServiceServer) ListNodeExecutions(_a0 context.Context, _a1 *admin.NodeExecutionListRequest) (*admin.NodeExecutionList, error)

+ func (_m *AdminServiceServer) ListNodeExecutionsForTask(_a0 context.Context, _a1 *admin.NodeExecutionForTaskListRequest) (*admin.NodeExecutionList, error)

+ func (_m *AdminServiceServer) ListProjects(_a0 context.Context, _a1 *admin.ProjectListRequest) (*admin.Projects, error)

+ func (_m *AdminServiceServer) ListTaskExecutions(_a0 context.Context, _a1 *admin.TaskExecutionListRequest) (*admin.TaskExecutionList, error)

+ func (_m *AdminServiceServer) ListTaskIds(_a0 context.Context, _a1 *admin.NamedEntityIdentifierListRequest) (*admin.NamedEntityIdentifierList, error)

+ func (_m *AdminServiceServer) ListTasks(_a0 context.Context, _a1 *admin.ResourceListRequest) (*admin.TaskList, error)

+ func (_m *AdminServiceServer) ListWorkflowIds(_a0 context.Context, _a1 *admin.NamedEntityIdentifierListRequest) (*admin.NamedEntityIdentifierList, error)

+ func (_m *AdminServiceServer) ListWorkflows(_a0 context.Context, _a1 *admin.ResourceListRequest) (*admin.WorkflowList, error)

+ func (_m *AdminServiceServer) OnCreateExecution(_a0 context.Context, _a1 *admin.ExecutionCreateRequest) *AdminServiceServer_CreateExecution

+ func (_m *AdminServiceServer) OnCreateExecutionMatch(matchers ...interface{}) *AdminServiceServer_CreateExecution

+ func (_m *AdminServiceServer) OnCreateLaunchPlan(_a0 context.Context, _a1 *admin.LaunchPlanCreateRequest) *AdminServiceServer_CreateLaunchPlan

+ func (_m *AdminServiceServer) OnCreateLaunchPlanMatch(matchers ...interface{}) *AdminServiceServer_CreateLaunchPlan

+ func (_m *AdminServiceServer) OnCreateNodeEvent(_a0 context.Context, _a1 *admin.NodeExecutionEventRequest) *AdminServiceServer_CreateNodeEvent

+ func (_m *AdminServiceServer) OnCreateNodeEventMatch(matchers ...interface{}) *AdminServiceServer_CreateNodeEvent

+ func (_m *AdminServiceServer) OnCreateTask(_a0 context.Context, _a1 *admin.TaskCreateRequest) *AdminServiceServer_CreateTask

+ func (_m *AdminServiceServer) OnCreateTaskEvent(_a0 context.Context, _a1 *admin.TaskExecutionEventRequest) *AdminServiceServer_CreateTaskEvent

+ func (_m *AdminServiceServer) OnCreateTaskEventMatch(matchers ...interface{}) *AdminServiceServer_CreateTaskEvent

+ func (_m *AdminServiceServer) OnCreateTaskMatch(matchers ...interface{}) *AdminServiceServer_CreateTask

+ func (_m *AdminServiceServer) OnCreateWorkflow(_a0 context.Context, _a1 *admin.WorkflowCreateRequest) *AdminServiceServer_CreateWorkflow

+ func (_m *AdminServiceServer) OnCreateWorkflowEvent(_a0 context.Context, _a1 *admin.WorkflowExecutionEventRequest) *AdminServiceServer_CreateWorkflowEvent

+ func (_m *AdminServiceServer) OnCreateWorkflowEventMatch(matchers ...interface{}) *AdminServiceServer_CreateWorkflowEvent

+ func (_m *AdminServiceServer) OnCreateWorkflowMatch(matchers ...interface{}) *AdminServiceServer_CreateWorkflow

+ func (_m *AdminServiceServer) OnDeleteProjectAttributes(_a0 context.Context, _a1 *admin.ProjectAttributesDeleteRequest) *AdminServiceServer_DeleteProjectAttributes

+ func (_m *AdminServiceServer) OnDeleteProjectAttributesMatch(matchers ...interface{}) *AdminServiceServer_DeleteProjectAttributes

+ func (_m *AdminServiceServer) OnDeleteProjectDomainAttributes(_a0 context.Context, _a1 *admin.ProjectDomainAttributesDeleteRequest) *AdminServiceServer_DeleteProjectDomainAttributes

+ func (_m *AdminServiceServer) OnDeleteProjectDomainAttributesMatch(matchers ...interface{}) *AdminServiceServer_DeleteProjectDomainAttributes

+ func (_m *AdminServiceServer) OnDeleteWorkflowAttributes(_a0 context.Context, _a1 *admin.WorkflowAttributesDeleteRequest) *AdminServiceServer_DeleteWorkflowAttributes

+ func (_m *AdminServiceServer) OnDeleteWorkflowAttributesMatch(matchers ...interface{}) *AdminServiceServer_DeleteWorkflowAttributes

+ func (_m *AdminServiceServer) OnGetActiveLaunchPlan(_a0 context.Context, _a1 *admin.ActiveLaunchPlanRequest) *AdminServiceServer_GetActiveLaunchPlan

+ func (_m *AdminServiceServer) OnGetActiveLaunchPlanMatch(matchers ...interface{}) *AdminServiceServer_GetActiveLaunchPlan

+ func (_m *AdminServiceServer) OnGetDescriptionEntity(_a0 context.Context, _a1 *admin.ObjectGetRequest) *AdminServiceServer_GetDescriptionEntity

+ func (_m *AdminServiceServer) OnGetDescriptionEntityMatch(matchers ...interface{}) *AdminServiceServer_GetDescriptionEntity

+ func (_m *AdminServiceServer) OnGetExecution(_a0 context.Context, _a1 *admin.WorkflowExecutionGetRequest) *AdminServiceServer_GetExecution

+ func (_m *AdminServiceServer) OnGetExecutionData(_a0 context.Context, _a1 *admin.WorkflowExecutionGetDataRequest) *AdminServiceServer_GetExecutionData

+ func (_m *AdminServiceServer) OnGetExecutionDataMatch(matchers ...interface{}) *AdminServiceServer_GetExecutionData

+ func (_m *AdminServiceServer) OnGetExecutionMatch(matchers ...interface{}) *AdminServiceServer_GetExecution

+ func (_m *AdminServiceServer) OnGetExecutionMetrics(_a0 context.Context, _a1 *admin.WorkflowExecutionGetMetricsRequest) *AdminServiceServer_GetExecutionMetrics

+ func (_m *AdminServiceServer) OnGetExecutionMetricsMatch(matchers ...interface{}) *AdminServiceServer_GetExecutionMetrics

+ func (_m *AdminServiceServer) OnGetLaunchPlan(_a0 context.Context, _a1 *admin.ObjectGetRequest) *AdminServiceServer_GetLaunchPlan

+ func (_m *AdminServiceServer) OnGetLaunchPlanMatch(matchers ...interface{}) *AdminServiceServer_GetLaunchPlan

+ func (_m *AdminServiceServer) OnGetNamedEntity(_a0 context.Context, _a1 *admin.NamedEntityGetRequest) *AdminServiceServer_GetNamedEntity

+ func (_m *AdminServiceServer) OnGetNamedEntityMatch(matchers ...interface{}) *AdminServiceServer_GetNamedEntity

+ func (_m *AdminServiceServer) OnGetNodeExecution(_a0 context.Context, _a1 *admin.NodeExecutionGetRequest) *AdminServiceServer_GetNodeExecution

+ func (_m *AdminServiceServer) OnGetNodeExecutionData(_a0 context.Context, _a1 *admin.NodeExecutionGetDataRequest) *AdminServiceServer_GetNodeExecutionData

+ func (_m *AdminServiceServer) OnGetNodeExecutionDataMatch(matchers ...interface{}) *AdminServiceServer_GetNodeExecutionData

+ func (_m *AdminServiceServer) OnGetNodeExecutionMatch(matchers ...interface{}) *AdminServiceServer_GetNodeExecution

+ func (_m *AdminServiceServer) OnGetProjectAttributes(_a0 context.Context, _a1 *admin.ProjectAttributesGetRequest) *AdminServiceServer_GetProjectAttributes

+ func (_m *AdminServiceServer) OnGetProjectAttributesMatch(matchers ...interface{}) *AdminServiceServer_GetProjectAttributes

+ func (_m *AdminServiceServer) OnGetProjectDomainAttributes(_a0 context.Context, _a1 *admin.ProjectDomainAttributesGetRequest) *AdminServiceServer_GetProjectDomainAttributes

+ func (_m *AdminServiceServer) OnGetProjectDomainAttributesMatch(matchers ...interface{}) *AdminServiceServer_GetProjectDomainAttributes

+ func (_m *AdminServiceServer) OnGetTask(_a0 context.Context, _a1 *admin.ObjectGetRequest) *AdminServiceServer_GetTask

+ func (_m *AdminServiceServer) OnGetTaskExecution(_a0 context.Context, _a1 *admin.TaskExecutionGetRequest) *AdminServiceServer_GetTaskExecution

+ func (_m *AdminServiceServer) OnGetTaskExecutionData(_a0 context.Context, _a1 *admin.TaskExecutionGetDataRequest) *AdminServiceServer_GetTaskExecutionData

+ func (_m *AdminServiceServer) OnGetTaskExecutionDataMatch(matchers ...interface{}) *AdminServiceServer_GetTaskExecutionData

+ func (_m *AdminServiceServer) OnGetTaskExecutionMatch(matchers ...interface{}) *AdminServiceServer_GetTaskExecution

+ func (_m *AdminServiceServer) OnGetTaskMatch(matchers ...interface{}) *AdminServiceServer_GetTask

+ func (_m *AdminServiceServer) OnGetVersion(_a0 context.Context, _a1 *admin.GetVersionRequest) *AdminServiceServer_GetVersion

+ func (_m *AdminServiceServer) OnGetVersionMatch(matchers ...interface{}) *AdminServiceServer_GetVersion

+ func (_m *AdminServiceServer) OnGetWorkflow(_a0 context.Context, _a1 *admin.ObjectGetRequest) *AdminServiceServer_GetWorkflow

+ func (_m *AdminServiceServer) OnGetWorkflowAttributes(_a0 context.Context, _a1 *admin.WorkflowAttributesGetRequest) *AdminServiceServer_GetWorkflowAttributes

+ func (_m *AdminServiceServer) OnGetWorkflowAttributesMatch(matchers ...interface{}) *AdminServiceServer_GetWorkflowAttributes

+ func (_m *AdminServiceServer) OnGetWorkflowMatch(matchers ...interface{}) *AdminServiceServer_GetWorkflow

+ func (_m *AdminServiceServer) OnListActiveLaunchPlans(_a0 context.Context, _a1 *admin.ActiveLaunchPlanListRequest) *AdminServiceServer_ListActiveLaunchPlans

+ func (_m *AdminServiceServer) OnListActiveLaunchPlansMatch(matchers ...interface{}) *AdminServiceServer_ListActiveLaunchPlans

+ func (_m *AdminServiceServer) OnListDescriptionEntities(_a0 context.Context, _a1 *admin.DescriptionEntityListRequest) *AdminServiceServer_ListDescriptionEntities

+ func (_m *AdminServiceServer) OnListDescriptionEntitiesMatch(matchers ...interface{}) *AdminServiceServer_ListDescriptionEntities

+ func (_m *AdminServiceServer) OnListExecutions(_a0 context.Context, _a1 *admin.ResourceListRequest) *AdminServiceServer_ListExecutions

+ func (_m *AdminServiceServer) OnListExecutionsMatch(matchers ...interface{}) *AdminServiceServer_ListExecutions

+ func (_m *AdminServiceServer) OnListLaunchPlanIds(_a0 context.Context, _a1 *admin.NamedEntityIdentifierListRequest) *AdminServiceServer_ListLaunchPlanIds

+ func (_m *AdminServiceServer) OnListLaunchPlanIdsMatch(matchers ...interface{}) *AdminServiceServer_ListLaunchPlanIds

+ func (_m *AdminServiceServer) OnListLaunchPlans(_a0 context.Context, _a1 *admin.ResourceListRequest) *AdminServiceServer_ListLaunchPlans

+ func (_m *AdminServiceServer) OnListLaunchPlansMatch(matchers ...interface{}) *AdminServiceServer_ListLaunchPlans

+ func (_m *AdminServiceServer) OnListMatchableAttributes(_a0 context.Context, _a1 *admin.ListMatchableAttributesRequest) *AdminServiceServer_ListMatchableAttributes

+ func (_m *AdminServiceServer) OnListMatchableAttributesMatch(matchers ...interface{}) *AdminServiceServer_ListMatchableAttributes

+ func (_m *AdminServiceServer) OnListNamedEntities(_a0 context.Context, _a1 *admin.NamedEntityListRequest) *AdminServiceServer_ListNamedEntities

+ func (_m *AdminServiceServer) OnListNamedEntitiesMatch(matchers ...interface{}) *AdminServiceServer_ListNamedEntities

+ func (_m *AdminServiceServer) OnListNodeExecutions(_a0 context.Context, _a1 *admin.NodeExecutionListRequest) *AdminServiceServer_ListNodeExecutions

+ func (_m *AdminServiceServer) OnListNodeExecutionsForTask(_a0 context.Context, _a1 *admin.NodeExecutionForTaskListRequest) *AdminServiceServer_ListNodeExecutionsForTask

+ func (_m *AdminServiceServer) OnListNodeExecutionsForTaskMatch(matchers ...interface{}) *AdminServiceServer_ListNodeExecutionsForTask

+ func (_m *AdminServiceServer) OnListNodeExecutionsMatch(matchers ...interface{}) *AdminServiceServer_ListNodeExecutions

+ func (_m *AdminServiceServer) OnListProjects(_a0 context.Context, _a1 *admin.ProjectListRequest) *AdminServiceServer_ListProjects

+ func (_m *AdminServiceServer) OnListProjectsMatch(matchers ...interface{}) *AdminServiceServer_ListProjects

+ func (_m *AdminServiceServer) OnListTaskExecutions(_a0 context.Context, _a1 *admin.TaskExecutionListRequest) *AdminServiceServer_ListTaskExecutions

+ func (_m *AdminServiceServer) OnListTaskExecutionsMatch(matchers ...interface{}) *AdminServiceServer_ListTaskExecutions

+ func (_m *AdminServiceServer) OnListTaskIds(_a0 context.Context, _a1 *admin.NamedEntityIdentifierListRequest) *AdminServiceServer_ListTaskIds

+ func (_m *AdminServiceServer) OnListTaskIdsMatch(matchers ...interface{}) *AdminServiceServer_ListTaskIds

+ func (_m *AdminServiceServer) OnListTasks(_a0 context.Context, _a1 *admin.ResourceListRequest) *AdminServiceServer_ListTasks

+ func (_m *AdminServiceServer) OnListTasksMatch(matchers ...interface{}) *AdminServiceServer_ListTasks

+ func (_m *AdminServiceServer) OnListWorkflowIds(_a0 context.Context, _a1 *admin.NamedEntityIdentifierListRequest) *AdminServiceServer_ListWorkflowIds

+ func (_m *AdminServiceServer) OnListWorkflowIdsMatch(matchers ...interface{}) *AdminServiceServer_ListWorkflowIds

+ func (_m *AdminServiceServer) OnListWorkflows(_a0 context.Context, _a1 *admin.ResourceListRequest) *AdminServiceServer_ListWorkflows

+ func (_m *AdminServiceServer) OnListWorkflowsMatch(matchers ...interface{}) *AdminServiceServer_ListWorkflows

+ func (_m *AdminServiceServer) OnRecoverExecution(_a0 context.Context, _a1 *admin.ExecutionRecoverRequest) *AdminServiceServer_RecoverExecution

+ func (_m *AdminServiceServer) OnRecoverExecutionMatch(matchers ...interface{}) *AdminServiceServer_RecoverExecution

+ func (_m *AdminServiceServer) OnRegisterProject(_a0 context.Context, _a1 *admin.ProjectRegisterRequest) *AdminServiceServer_RegisterProject

+ func (_m *AdminServiceServer) OnRegisterProjectMatch(matchers ...interface{}) *AdminServiceServer_RegisterProject

+ func (_m *AdminServiceServer) OnRelaunchExecution(_a0 context.Context, _a1 *admin.ExecutionRelaunchRequest) *AdminServiceServer_RelaunchExecution

+ func (_m *AdminServiceServer) OnRelaunchExecutionMatch(matchers ...interface{}) *AdminServiceServer_RelaunchExecution

+ func (_m *AdminServiceServer) OnTerminateExecution(_a0 context.Context, _a1 *admin.ExecutionTerminateRequest) *AdminServiceServer_TerminateExecution

+ func (_m *AdminServiceServer) OnTerminateExecutionMatch(matchers ...interface{}) *AdminServiceServer_TerminateExecution

+ func (_m *AdminServiceServer) OnUpdateExecution(_a0 context.Context, _a1 *admin.ExecutionUpdateRequest) *AdminServiceServer_UpdateExecution

+ func (_m *AdminServiceServer) OnUpdateExecutionMatch(matchers ...interface{}) *AdminServiceServer_UpdateExecution

+ func (_m *AdminServiceServer) OnUpdateLaunchPlan(_a0 context.Context, _a1 *admin.LaunchPlanUpdateRequest) *AdminServiceServer_UpdateLaunchPlan

+ func (_m *AdminServiceServer) OnUpdateLaunchPlanMatch(matchers ...interface{}) *AdminServiceServer_UpdateLaunchPlan

+ func (_m *AdminServiceServer) OnUpdateNamedEntity(_a0 context.Context, _a1 *admin.NamedEntityUpdateRequest) *AdminServiceServer_UpdateNamedEntity

+ func (_m *AdminServiceServer) OnUpdateNamedEntityMatch(matchers ...interface{}) *AdminServiceServer_UpdateNamedEntity

+ func (_m *AdminServiceServer) OnUpdateProject(_a0 context.Context, _a1 *admin.Project) *AdminServiceServer_UpdateProject

+ func (_m *AdminServiceServer) OnUpdateProjectAttributes(_a0 context.Context, _a1 *admin.ProjectAttributesUpdateRequest) *AdminServiceServer_UpdateProjectAttributes

+ func (_m *AdminServiceServer) OnUpdateProjectAttributesMatch(matchers ...interface{}) *AdminServiceServer_UpdateProjectAttributes

+ func (_m *AdminServiceServer) OnUpdateProjectDomainAttributes(_a0 context.Context, _a1 *admin.ProjectDomainAttributesUpdateRequest) *AdminServiceServer_UpdateProjectDomainAttributes

+ func (_m *AdminServiceServer) OnUpdateProjectDomainAttributesMatch(matchers ...interface{}) *AdminServiceServer_UpdateProjectDomainAttributes

+ func (_m *AdminServiceServer) OnUpdateProjectMatch(matchers ...interface{}) *AdminServiceServer_UpdateProject

+ func (_m *AdminServiceServer) OnUpdateWorkflowAttributes(_a0 context.Context, _a1 *admin.WorkflowAttributesUpdateRequest) *AdminServiceServer_UpdateWorkflowAttributes

+ func (_m *AdminServiceServer) OnUpdateWorkflowAttributesMatch(matchers ...interface{}) *AdminServiceServer_UpdateWorkflowAttributes

+ func (_m *AdminServiceServer) RecoverExecution(_a0 context.Context, _a1 *admin.ExecutionRecoverRequest) (*admin.ExecutionCreateResponse, error)

+ func (_m *AdminServiceServer) RegisterProject(_a0 context.Context, _a1 *admin.ProjectRegisterRequest) (*admin.ProjectRegisterResponse, error)

+ func (_m *AdminServiceServer) RelaunchExecution(_a0 context.Context, _a1 *admin.ExecutionRelaunchRequest) (*admin.ExecutionCreateResponse, error)

+ func (_m *AdminServiceServer) TerminateExecution(_a0 context.Context, _a1 *admin.ExecutionTerminateRequest) (*admin.ExecutionTerminateResponse, error)

+ func (_m *AdminServiceServer) UpdateExecution(_a0 context.Context, _a1 *admin.ExecutionUpdateRequest) (*admin.ExecutionUpdateResponse, error)

+ func (_m *AdminServiceServer) UpdateLaunchPlan(_a0 context.Context, _a1 *admin.LaunchPlanUpdateRequest) (*admin.LaunchPlanUpdateResponse, error)

+ func (_m *AdminServiceServer) UpdateNamedEntity(_a0 context.Context, _a1 *admin.NamedEntityUpdateRequest) (*admin.NamedEntityUpdateResponse, error)

+ func (_m *AdminServiceServer) UpdateProject(_a0 context.Context, _a1 *admin.Project) (*admin.ProjectUpdateResponse, error)

+ func (_m *AdminServiceServer) UpdateProjectAttributes(_a0 context.Context, _a1 *admin.ProjectAttributesUpdateRequest) (*admin.ProjectAttributesUpdateResponse, error)

+ func (_m *AdminServiceServer) UpdateProjectDomainAttributes(_a0 context.Context, _a1 *admin.ProjectDomainAttributesUpdateRequest) (*admin.ProjectDomainAttributesUpdateResponse, error)

+ func (_m *AdminServiceServer) UpdateWorkflowAttributes(_a0 context.Context, _a1 *admin.WorkflowAttributesUpdateRequest) (*admin.WorkflowAttributesUpdateResponse, error)

+ type AdminServiceServer_CreateExecution struct

+ func (_m AdminServiceServer_CreateExecution) Return(_a0 *admin.ExecutionCreateResponse, _a1 error) *AdminServiceServer_CreateExecution

+ type AdminServiceServer_CreateLaunchPlan struct

+ func (_m AdminServiceServer_CreateLaunchPlan) Return(_a0 *admin.LaunchPlanCreateResponse, _a1 error) *AdminServiceServer_CreateLaunchPlan

+ type AdminServiceServer_CreateNodeEvent struct

+ func (_m AdminServiceServer_CreateNodeEvent) Return(_a0 *admin.NodeExecutionEventResponse, _a1 error) *AdminServiceServer_CreateNodeEvent

+ type AdminServiceServer_CreateTask struct

+ func (_m AdminServiceServer_CreateTask) Return(_a0 *admin.TaskCreateResponse, _a1 error) *AdminServiceServer_CreateTask

+ type AdminServiceServer_CreateTaskEvent struct

+ func (_m AdminServiceServer_CreateTaskEvent) Return(_a0 *admin.TaskExecutionEventResponse, _a1 error) *AdminServiceServer_CreateTaskEvent

+ type AdminServiceServer_CreateWorkflow struct

+ func (_m AdminServiceServer_CreateWorkflow) Return(_a0 *admin.WorkflowCreateResponse, _a1 error) *AdminServiceServer_CreateWorkflow

+ type AdminServiceServer_CreateWorkflowEvent struct

+ func (_m AdminServiceServer_CreateWorkflowEvent) Return(_a0 *admin.WorkflowExecutionEventResponse, _a1 error) *AdminServiceServer_CreateWorkflowEvent

+ type AdminServiceServer_DeleteProjectAttributes struct

+ func (_m AdminServiceServer_DeleteProjectAttributes) Return(_a0 *admin.ProjectAttributesDeleteResponse, _a1 error) *AdminServiceServer_DeleteProjectAttributes

+ type AdminServiceServer_DeleteProjectDomainAttributes struct

+ func (_m AdminServiceServer_DeleteProjectDomainAttributes) Return(_a0 *admin.ProjectDomainAttributesDeleteResponse, _a1 error) *AdminServiceServer_DeleteProjectDomainAttributes

+ type AdminServiceServer_DeleteWorkflowAttributes struct

+ func (_m AdminServiceServer_DeleteWorkflowAttributes) Return(_a0 *admin.WorkflowAttributesDeleteResponse, _a1 error) *AdminServiceServer_DeleteWorkflowAttributes

+ type AdminServiceServer_GetActiveLaunchPlan struct

+ func (_m AdminServiceServer_GetActiveLaunchPlan) Return(_a0 *admin.LaunchPlan, _a1 error) *AdminServiceServer_GetActiveLaunchPlan

+ type AdminServiceServer_GetDescriptionEntity struct

+ func (_m AdminServiceServer_GetDescriptionEntity) Return(_a0 *admin.DescriptionEntity, _a1 error) *AdminServiceServer_GetDescriptionEntity

+ type AdminServiceServer_GetExecution struct

+ func (_m AdminServiceServer_GetExecution) Return(_a0 *admin.Execution, _a1 error) *AdminServiceServer_GetExecution

+ type AdminServiceServer_GetExecutionData struct

+ func (_m AdminServiceServer_GetExecutionData) Return(_a0 *admin.WorkflowExecutionGetDataResponse, _a1 error) *AdminServiceServer_GetExecutionData

+ type AdminServiceServer_GetExecutionMetrics struct

+ func (_m AdminServiceServer_GetExecutionMetrics) Return(_a0 *admin.WorkflowExecutionGetMetricsResponse, _a1 error) *AdminServiceServer_GetExecutionMetrics

+ type AdminServiceServer_GetLaunchPlan struct

+ func (_m AdminServiceServer_GetLaunchPlan) Return(_a0 *admin.LaunchPlan, _a1 error) *AdminServiceServer_GetLaunchPlan

+ type AdminServiceServer_GetNamedEntity struct

+ func (_m AdminServiceServer_GetNamedEntity) Return(_a0 *admin.NamedEntity, _a1 error) *AdminServiceServer_GetNamedEntity

+ type AdminServiceServer_GetNodeExecution struct

+ func (_m AdminServiceServer_GetNodeExecution) Return(_a0 *admin.NodeExecution, _a1 error) *AdminServiceServer_GetNodeExecution

+ type AdminServiceServer_GetNodeExecutionData struct

+ func (_m AdminServiceServer_GetNodeExecutionData) Return(_a0 *admin.NodeExecutionGetDataResponse, _a1 error) *AdminServiceServer_GetNodeExecutionData

+ type AdminServiceServer_GetProjectAttributes struct

+ func (_m AdminServiceServer_GetProjectAttributes) Return(_a0 *admin.ProjectAttributesGetResponse, _a1 error) *AdminServiceServer_GetProjectAttributes

+ type AdminServiceServer_GetProjectDomainAttributes struct

+ func (_m AdminServiceServer_GetProjectDomainAttributes) Return(_a0 *admin.ProjectDomainAttributesGetResponse, _a1 error) *AdminServiceServer_GetProjectDomainAttributes

+ type AdminServiceServer_GetTask struct

+ func (_m AdminServiceServer_GetTask) Return(_a0 *admin.Task, _a1 error) *AdminServiceServer_GetTask

+ type AdminServiceServer_GetTaskExecution struct

+ func (_m AdminServiceServer_GetTaskExecution) Return(_a0 *admin.TaskExecution, _a1 error) *AdminServiceServer_GetTaskExecution

+ type AdminServiceServer_GetTaskExecutionData struct

+ func (_m AdminServiceServer_GetTaskExecutionData) Return(_a0 *admin.TaskExecutionGetDataResponse, _a1 error) *AdminServiceServer_GetTaskExecutionData

+ type AdminServiceServer_GetVersion struct

+ func (_m AdminServiceServer_GetVersion) Return(_a0 *admin.GetVersionResponse, _a1 error) *AdminServiceServer_GetVersion

+ type AdminServiceServer_GetWorkflow struct

+ func (_m AdminServiceServer_GetWorkflow) Return(_a0 *admin.Workflow, _a1 error) *AdminServiceServer_GetWorkflow

+ type AdminServiceServer_GetWorkflowAttributes struct

+ func (_m AdminServiceServer_GetWorkflowAttributes) Return(_a0 *admin.WorkflowAttributesGetResponse, _a1 error) *AdminServiceServer_GetWorkflowAttributes

+ type AdminServiceServer_ListActiveLaunchPlans struct

+ func (_m AdminServiceServer_ListActiveLaunchPlans) Return(_a0 *admin.LaunchPlanList, _a1 error) *AdminServiceServer_ListActiveLaunchPlans

+ type AdminServiceServer_ListDescriptionEntities struct

+ func (_m AdminServiceServer_ListDescriptionEntities) Return(_a0 *admin.DescriptionEntityList, _a1 error) *AdminServiceServer_ListDescriptionEntities

+ type AdminServiceServer_ListExecutions struct

+ func (_m AdminServiceServer_ListExecutions) Return(_a0 *admin.ExecutionList, _a1 error) *AdminServiceServer_ListExecutions

+ type AdminServiceServer_ListLaunchPlanIds struct

+ func (_m AdminServiceServer_ListLaunchPlanIds) Return(_a0 *admin.NamedEntityIdentifierList, _a1 error) *AdminServiceServer_ListLaunchPlanIds

+ type AdminServiceServer_ListLaunchPlans struct

+ func (_m AdminServiceServer_ListLaunchPlans) Return(_a0 *admin.LaunchPlanList, _a1 error) *AdminServiceServer_ListLaunchPlans

+ type AdminServiceServer_ListMatchableAttributes struct

+ func (_m AdminServiceServer_ListMatchableAttributes) Return(_a0 *admin.ListMatchableAttributesResponse, _a1 error) *AdminServiceServer_ListMatchableAttributes

+ type AdminServiceServer_ListNamedEntities struct

+ func (_m AdminServiceServer_ListNamedEntities) Return(_a0 *admin.NamedEntityList, _a1 error) *AdminServiceServer_ListNamedEntities

+ type AdminServiceServer_ListNodeExecutions struct

+ func (_m AdminServiceServer_ListNodeExecutions) Return(_a0 *admin.NodeExecutionList, _a1 error) *AdminServiceServer_ListNodeExecutions

+ type AdminServiceServer_ListNodeExecutionsForTask struct

+ func (_m AdminServiceServer_ListNodeExecutionsForTask) Return(_a0 *admin.NodeExecutionList, _a1 error) *AdminServiceServer_ListNodeExecutionsForTask

+ type AdminServiceServer_ListProjects struct

+ func (_m AdminServiceServer_ListProjects) Return(_a0 *admin.Projects, _a1 error) *AdminServiceServer_ListProjects

+ type AdminServiceServer_ListTaskExecutions struct

+ func (_m AdminServiceServer_ListTaskExecutions) Return(_a0 *admin.TaskExecutionList, _a1 error) *AdminServiceServer_ListTaskExecutions

+ type AdminServiceServer_ListTaskIds struct

+ func (_m AdminServiceServer_ListTaskIds) Return(_a0 *admin.NamedEntityIdentifierList, _a1 error) *AdminServiceServer_ListTaskIds

+ type AdminServiceServer_ListTasks struct

+ func (_m AdminServiceServer_ListTasks) Return(_a0 *admin.TaskList, _a1 error) *AdminServiceServer_ListTasks

+ type AdminServiceServer_ListWorkflowIds struct

+ func (_m AdminServiceServer_ListWorkflowIds) Return(_a0 *admin.NamedEntityIdentifierList, _a1 error) *AdminServiceServer_ListWorkflowIds

+ type AdminServiceServer_ListWorkflows struct

+ func (_m AdminServiceServer_ListWorkflows) Return(_a0 *admin.WorkflowList, _a1 error) *AdminServiceServer_ListWorkflows

+ type AdminServiceServer_RecoverExecution struct

+ func (_m AdminServiceServer_RecoverExecution) Return(_a0 *admin.ExecutionCreateResponse, _a1 error) *AdminServiceServer_RecoverExecution

+ type AdminServiceServer_RegisterProject struct

+ func (_m AdminServiceServer_RegisterProject) Return(_a0 *admin.ProjectRegisterResponse, _a1 error) *AdminServiceServer_RegisterProject

+ type AdminServiceServer_RelaunchExecution struct

+ func (_m AdminServiceServer_RelaunchExecution) Return(_a0 *admin.ExecutionCreateResponse, _a1 error) *AdminServiceServer_RelaunchExecution

+ type AdminServiceServer_TerminateExecution struct

+ func (_m AdminServiceServer_TerminateExecution) Return(_a0 *admin.ExecutionTerminateResponse, _a1 error) *AdminServiceServer_TerminateExecution

+ type AdminServiceServer_UpdateExecution struct

+ func (_m AdminServiceServer_UpdateExecution) Return(_a0 *admin.ExecutionUpdateResponse, _a1 error) *AdminServiceServer_UpdateExecution

+ type AdminServiceServer_UpdateLaunchPlan struct

+ func (_m AdminServiceServer_UpdateLaunchPlan) Return(_a0 *admin.LaunchPlanUpdateResponse, _a1 error) *AdminServiceServer_UpdateLaunchPlan

+ type AdminServiceServer_UpdateNamedEntity struct

+ func (_m AdminServiceServer_UpdateNamedEntity) Return(_a0 *admin.NamedEntityUpdateResponse, _a1 error) *AdminServiceServer_UpdateNamedEntity

+ type AdminServiceServer_UpdateProject struct

+ func (_m AdminServiceServer_UpdateProject) Return(_a0 *admin.ProjectUpdateResponse, _a1 error) *AdminServiceServer_UpdateProject

+ type AdminServiceServer_UpdateProjectAttributes struct

+ func (_m AdminServiceServer_UpdateProjectAttributes) Return(_a0 *admin.ProjectAttributesUpdateResponse, _a1 error) *AdminServiceServer_UpdateProjectAttributes

+ type AdminServiceServer_UpdateProjectDomainAttributes struct

+ func (_m AdminServiceServer_UpdateProjectDomainAttributes) Return(_a0 *admin.ProjectDomainAttributesUpdateResponse, _a1 error) *AdminServiceServer_UpdateProjectDomainAttributes

+ type AdminServiceServer_UpdateWorkflowAttributes struct

+ func (_m AdminServiceServer_UpdateWorkflowAttributes) Return(_a0 *admin.WorkflowAttributesUpdateResponse, _a1 error) *AdminServiceServer_UpdateWorkflowAttributes

+ type AgentServiceClient struct

+ func (_m *AgentServiceClient) CreateTask(ctx context.Context, in *admin.CreateTaskRequest, opts ...grpc.CallOption) (*admin.CreateTaskResponse, error)

+ func (_m *AgentServiceClient) DeleteTask(ctx context.Context, in *admin.DeleteTaskRequest, opts ...grpc.CallOption) (*admin.DeleteTaskResponse, error)

+ func (_m *AgentServiceClient) GetTask(ctx context.Context, in *admin.GetTaskRequest, opts ...grpc.CallOption) (*admin.GetTaskResponse, error)

+ func (_m *AgentServiceClient) OnCreateTask(ctx context.Context, in *admin.CreateTaskRequest, opts ...grpc.CallOption) *AgentServiceClient_CreateTask

+ func (_m *AgentServiceClient) OnCreateTaskMatch(matchers ...interface{}) *AgentServiceClient_CreateTask

+ func (_m *AgentServiceClient) OnDeleteTask(ctx context.Context, in *admin.DeleteTaskRequest, opts ...grpc.CallOption) *AgentServiceClient_DeleteTask

+ func (_m *AgentServiceClient) OnDeleteTaskMatch(matchers ...interface{}) *AgentServiceClient_DeleteTask

+ func (_m *AgentServiceClient) OnGetTask(ctx context.Context, in *admin.GetTaskRequest, opts ...grpc.CallOption) *AgentServiceClient_GetTask

+ func (_m *AgentServiceClient) OnGetTaskMatch(matchers ...interface{}) *AgentServiceClient_GetTask

+ type AgentServiceClient_CreateTask struct

+ func (_m AgentServiceClient_CreateTask) Return(_a0 *admin.CreateTaskResponse, _a1 error) *AgentServiceClient_CreateTask

+ type AgentServiceClient_DeleteTask struct

+ func (_m AgentServiceClient_DeleteTask) Return(_a0 *admin.DeleteTaskResponse, _a1 error) *AgentServiceClient_DeleteTask

+ type AgentServiceClient_GetTask struct

+ func (_m AgentServiceClient_GetTask) Return(_a0 *admin.GetTaskResponse, _a1 error) *AgentServiceClient_GetTask

+ type AgentServiceServer struct

+ func (_m *AgentServiceServer) CreateTask(_a0 context.Context, _a1 *admin.CreateTaskRequest) (*admin.CreateTaskResponse, error)

+ func (_m *AgentServiceServer) DeleteTask(_a0 context.Context, _a1 *admin.DeleteTaskRequest) (*admin.DeleteTaskResponse, error)

+ func (_m *AgentServiceServer) GetTask(_a0 context.Context, _a1 *admin.GetTaskRequest) (*admin.GetTaskResponse, error)

+ func (_m *AgentServiceServer) OnCreateTask(_a0 context.Context, _a1 *admin.CreateTaskRequest) *AgentServiceServer_CreateTask

+ func (_m *AgentServiceServer) OnCreateTaskMatch(matchers ...interface{}) *AgentServiceServer_CreateTask

+ func (_m *AgentServiceServer) OnDeleteTask(_a0 context.Context, _a1 *admin.DeleteTaskRequest) *AgentServiceServer_DeleteTask

+ func (_m *AgentServiceServer) OnDeleteTaskMatch(matchers ...interface{}) *AgentServiceServer_DeleteTask

+ func (_m *AgentServiceServer) OnGetTask(_a0 context.Context, _a1 *admin.GetTaskRequest) *AgentServiceServer_GetTask

+ func (_m *AgentServiceServer) OnGetTaskMatch(matchers ...interface{}) *AgentServiceServer_GetTask

+ type AgentServiceServer_CreateTask struct

+ func (_m AgentServiceServer_CreateTask) Return(_a0 *admin.CreateTaskResponse, _a1 error) *AgentServiceServer_CreateTask

+ type AgentServiceServer_DeleteTask struct

+ func (_m AgentServiceServer_DeleteTask) Return(_a0 *admin.DeleteTaskResponse, _a1 error) *AgentServiceServer_DeleteTask

+ type AgentServiceServer_GetTask struct

+ func (_m AgentServiceServer_GetTask) Return(_a0 *admin.GetTaskResponse, _a1 error) *AgentServiceServer_GetTask

+ type AsyncAgentServiceClient struct

+ func (_m *AsyncAgentServiceClient) CreateTask(ctx context.Context, in *admin.CreateTaskRequest, opts ...grpc.CallOption) (*admin.CreateTaskResponse, error)

+ func (_m *AsyncAgentServiceClient) DeleteTask(ctx context.Context, in *admin.DeleteTaskRequest, opts ...grpc.CallOption) (*admin.DeleteTaskResponse, error)

+ func (_m *AsyncAgentServiceClient) GetTask(ctx context.Context, in *admin.GetTaskRequest, opts ...grpc.CallOption) (*admin.GetTaskResponse, error)

+ func (_m *AsyncAgentServiceClient) OnCreateTask(ctx context.Context, in *admin.CreateTaskRequest, opts ...grpc.CallOption) *AsyncAgentServiceClient_CreateTask

+ func (_m *AsyncAgentServiceClient) OnCreateTaskMatch(matchers ...interface{}) *AsyncAgentServiceClient_CreateTask

+ func (_m *AsyncAgentServiceClient) OnDeleteTask(ctx context.Context, in *admin.DeleteTaskRequest, opts ...grpc.CallOption) *AsyncAgentServiceClient_DeleteTask

+ func (_m *AsyncAgentServiceClient) OnDeleteTaskMatch(matchers ...interface{}) *AsyncAgentServiceClient_DeleteTask

+ func (_m *AsyncAgentServiceClient) OnGetTask(ctx context.Context, in *admin.GetTaskRequest, opts ...grpc.CallOption) *AsyncAgentServiceClient_GetTask

+ func (_m *AsyncAgentServiceClient) OnGetTaskMatch(matchers ...interface{}) *AsyncAgentServiceClient_GetTask

+ type AsyncAgentServiceClient_CreateTask struct

+ func (_m AsyncAgentServiceClient_CreateTask) Return(_a0 *admin.CreateTaskResponse, _a1 error) *AsyncAgentServiceClient_CreateTask

+ type AsyncAgentServiceClient_DeleteTask struct

+ func (_m AsyncAgentServiceClient_DeleteTask) Return(_a0 *admin.DeleteTaskResponse, _a1 error) *AsyncAgentServiceClient_DeleteTask

+ type AsyncAgentServiceClient_GetTask struct

+ func (_m AsyncAgentServiceClient_GetTask) Return(_a0 *admin.GetTaskResponse, _a1 error) *AsyncAgentServiceClient_GetTask

+ type AsyncAgentServiceServer struct

+ func (_m *AsyncAgentServiceServer) CreateTask(_a0 context.Context, _a1 *admin.CreateTaskRequest) (*admin.CreateTaskResponse, error)

+ func (_m *AsyncAgentServiceServer) DeleteTask(_a0 context.Context, _a1 *admin.DeleteTaskRequest) (*admin.DeleteTaskResponse, error)

+ func (_m *AsyncAgentServiceServer) GetTask(_a0 context.Context, _a1 *admin.GetTaskRequest) (*admin.GetTaskResponse, error)

+ func (_m *AsyncAgentServiceServer) OnCreateTask(_a0 context.Context, _a1 *admin.CreateTaskRequest) *AsyncAgentServiceServer_CreateTask

+ func (_m *AsyncAgentServiceServer) OnCreateTaskMatch(matchers ...interface{}) *AsyncAgentServiceServer_CreateTask

+ func (_m *AsyncAgentServiceServer) OnDeleteTask(_a0 context.Context, _a1 *admin.DeleteTaskRequest) *AsyncAgentServiceServer_DeleteTask

+ func (_m *AsyncAgentServiceServer) OnDeleteTaskMatch(matchers ...interface{}) *AsyncAgentServiceServer_DeleteTask

+ func (_m *AsyncAgentServiceServer) OnGetTask(_a0 context.Context, _a1 *admin.GetTaskRequest) *AsyncAgentServiceServer_GetTask

+ func (_m *AsyncAgentServiceServer) OnGetTaskMatch(matchers ...interface{}) *AsyncAgentServiceServer_GetTask

+ type AsyncAgentServiceServer_CreateTask struct

+ func (_m AsyncAgentServiceServer_CreateTask) Return(_a0 *admin.CreateTaskResponse, _a1 error) *AsyncAgentServiceServer_CreateTask

+ type AsyncAgentServiceServer_DeleteTask struct

+ func (_m AsyncAgentServiceServer_DeleteTask) Return(_a0 *admin.DeleteTaskResponse, _a1 error) *AsyncAgentServiceServer_DeleteTask

+ type AsyncAgentServiceServer_GetTask struct

+ func (_m AsyncAgentServiceServer_GetTask) Return(_a0 *admin.GetTaskResponse, _a1 error) *AsyncAgentServiceServer_GetTask

+ type AuthMetadataServiceClient struct

+ func (_m *AuthMetadataServiceClient) GetOAuth2Metadata(ctx context.Context, in *service.OAuth2MetadataRequest, ...) (*service.OAuth2MetadataResponse, error)

+ func (_m *AuthMetadataServiceClient) GetPublicClientConfig(ctx context.Context, in *service.PublicClientAuthConfigRequest, ...) (*service.PublicClientAuthConfigResponse, error)

+ func (_m *AuthMetadataServiceClient) OnGetOAuth2Metadata(ctx context.Context, in *service.OAuth2MetadataRequest, ...) *AuthMetadataServiceClient_GetOAuth2Metadata

+ func (_m *AuthMetadataServiceClient) OnGetOAuth2MetadataMatch(matchers ...interface{}) *AuthMetadataServiceClient_GetOAuth2Metadata

+ func (_m *AuthMetadataServiceClient) OnGetPublicClientConfig(ctx context.Context, in *service.PublicClientAuthConfigRequest, ...) *AuthMetadataServiceClient_GetPublicClientConfig

+ func (_m *AuthMetadataServiceClient) OnGetPublicClientConfigMatch(matchers ...interface{}) *AuthMetadataServiceClient_GetPublicClientConfig

+ type AuthMetadataServiceClient_GetOAuth2Metadata struct

+ func (_m AuthMetadataServiceClient_GetOAuth2Metadata) Return(_a0 *service.OAuth2MetadataResponse, _a1 error) *AuthMetadataServiceClient_GetOAuth2Metadata

+ type AuthMetadataServiceClient_GetPublicClientConfig struct

+ func (_m AuthMetadataServiceClient_GetPublicClientConfig) Return(_a0 *service.PublicClientAuthConfigResponse, _a1 error) *AuthMetadataServiceClient_GetPublicClientConfig

+ type AuthMetadataServiceServer struct

+ func (_m *AuthMetadataServiceServer) GetOAuth2Metadata(_a0 context.Context, _a1 *service.OAuth2MetadataRequest) (*service.OAuth2MetadataResponse, error)

+ func (_m *AuthMetadataServiceServer) GetPublicClientConfig(_a0 context.Context, _a1 *service.PublicClientAuthConfigRequest) (*service.PublicClientAuthConfigResponse, error)

+ func (_m *AuthMetadataServiceServer) OnGetOAuth2Metadata(_a0 context.Context, _a1 *service.OAuth2MetadataRequest) *AuthMetadataServiceServer_GetOAuth2Metadata

+ func (_m *AuthMetadataServiceServer) OnGetOAuth2MetadataMatch(matchers ...interface{}) *AuthMetadataServiceServer_GetOAuth2Metadata

+ func (_m *AuthMetadataServiceServer) OnGetPublicClientConfig(_a0 context.Context, _a1 *service.PublicClientAuthConfigRequest) *AuthMetadataServiceServer_GetPublicClientConfig

+ func (_m *AuthMetadataServiceServer) OnGetPublicClientConfigMatch(matchers ...interface{}) *AuthMetadataServiceServer_GetPublicClientConfig

+ type AuthMetadataServiceServer_GetOAuth2Metadata struct

+ func (_m AuthMetadataServiceServer_GetOAuth2Metadata) Return(_a0 *service.OAuth2MetadataResponse, _a1 error) *AuthMetadataServiceServer_GetOAuth2Metadata

+ type AuthMetadataServiceServer_GetPublicClientConfig struct

+ func (_m AuthMetadataServiceServer_GetPublicClientConfig) Return(_a0 *service.PublicClientAuthConfigResponse, _a1 error) *AuthMetadataServiceServer_GetPublicClientConfig

+ type DataProxyServiceClient struct

+ func (_m *DataProxyServiceClient) CreateDownloadLink(ctx context.Context, in *service.CreateDownloadLinkRequest, ...) (*service.CreateDownloadLinkResponse, error)

+ func (_m *DataProxyServiceClient) CreateDownloadLocation(ctx context.Context, in *service.CreateDownloadLocationRequest, ...) (*service.CreateDownloadLocationResponse, error)

+ func (_m *DataProxyServiceClient) CreateUploadLocation(ctx context.Context, in *service.CreateUploadLocationRequest, ...) (*service.CreateUploadLocationResponse, error)

+ func (_m *DataProxyServiceClient) GetData(ctx context.Context, in *service.GetDataRequest, opts ...grpc.CallOption) (*service.GetDataResponse, error)

+ func (_m *DataProxyServiceClient) OnCreateDownloadLink(ctx context.Context, in *service.CreateDownloadLinkRequest, ...) *DataProxyServiceClient_CreateDownloadLink

+ func (_m *DataProxyServiceClient) OnCreateDownloadLinkMatch(matchers ...interface{}) *DataProxyServiceClient_CreateDownloadLink

+ func (_m *DataProxyServiceClient) OnCreateDownloadLocation(ctx context.Context, in *service.CreateDownloadLocationRequest, ...) *DataProxyServiceClient_CreateDownloadLocation

+ func (_m *DataProxyServiceClient) OnCreateDownloadLocationMatch(matchers ...interface{}) *DataProxyServiceClient_CreateDownloadLocation

+ func (_m *DataProxyServiceClient) OnCreateUploadLocation(ctx context.Context, in *service.CreateUploadLocationRequest, ...) *DataProxyServiceClient_CreateUploadLocation

+ func (_m *DataProxyServiceClient) OnCreateUploadLocationMatch(matchers ...interface{}) *DataProxyServiceClient_CreateUploadLocation

+ func (_m *DataProxyServiceClient) OnGetData(ctx context.Context, in *service.GetDataRequest, opts ...grpc.CallOption) *DataProxyServiceClient_GetData

+ func (_m *DataProxyServiceClient) OnGetDataMatch(matchers ...interface{}) *DataProxyServiceClient_GetData

+ type DataProxyServiceClient_CreateDownloadLink struct

+ func (_m DataProxyServiceClient_CreateDownloadLink) Return(_a0 *service.CreateDownloadLinkResponse, _a1 error) *DataProxyServiceClient_CreateDownloadLink

+ type DataProxyServiceClient_CreateDownloadLocation struct

+ func (_m DataProxyServiceClient_CreateDownloadLocation) Return(_a0 *service.CreateDownloadLocationResponse, _a1 error) *DataProxyServiceClient_CreateDownloadLocation

+ type DataProxyServiceClient_CreateUploadLocation struct

+ func (_m DataProxyServiceClient_CreateUploadLocation) Return(_a0 *service.CreateUploadLocationResponse, _a1 error) *DataProxyServiceClient_CreateUploadLocation

+ type DataProxyServiceClient_GetData struct

+ func (_m DataProxyServiceClient_GetData) Return(_a0 *service.GetDataResponse, _a1 error) *DataProxyServiceClient_GetData

+ type DataProxyServiceServer struct

+ func (_m *DataProxyServiceServer) CreateDownloadLink(_a0 context.Context, _a1 *service.CreateDownloadLinkRequest) (*service.CreateDownloadLinkResponse, error)

+ func (_m *DataProxyServiceServer) CreateDownloadLocation(_a0 context.Context, _a1 *service.CreateDownloadLocationRequest) (*service.CreateDownloadLocationResponse, error)

+ func (_m *DataProxyServiceServer) CreateUploadLocation(_a0 context.Context, _a1 *service.CreateUploadLocationRequest) (*service.CreateUploadLocationResponse, error)

+ func (_m *DataProxyServiceServer) GetData(_a0 context.Context, _a1 *service.GetDataRequest) (*service.GetDataResponse, error)

+ func (_m *DataProxyServiceServer) OnCreateDownloadLink(_a0 context.Context, _a1 *service.CreateDownloadLinkRequest) *DataProxyServiceServer_CreateDownloadLink

+ func (_m *DataProxyServiceServer) OnCreateDownloadLinkMatch(matchers ...interface{}) *DataProxyServiceServer_CreateDownloadLink

+ func (_m *DataProxyServiceServer) OnCreateDownloadLocation(_a0 context.Context, _a1 *service.CreateDownloadLocationRequest) *DataProxyServiceServer_CreateDownloadLocation

+ func (_m *DataProxyServiceServer) OnCreateDownloadLocationMatch(matchers ...interface{}) *DataProxyServiceServer_CreateDownloadLocation

+ func (_m *DataProxyServiceServer) OnCreateUploadLocation(_a0 context.Context, _a1 *service.CreateUploadLocationRequest) *DataProxyServiceServer_CreateUploadLocation

+ func (_m *DataProxyServiceServer) OnCreateUploadLocationMatch(matchers ...interface{}) *DataProxyServiceServer_CreateUploadLocation

+ func (_m *DataProxyServiceServer) OnGetData(_a0 context.Context, _a1 *service.GetDataRequest) *DataProxyServiceServer_GetData

+ func (_m *DataProxyServiceServer) OnGetDataMatch(matchers ...interface{}) *DataProxyServiceServer_GetData

+ type DataProxyServiceServer_CreateDownloadLink struct

+ func (_m DataProxyServiceServer_CreateDownloadLink) Return(_a0 *service.CreateDownloadLinkResponse, _a1 error) *DataProxyServiceServer_CreateDownloadLink

+ type DataProxyServiceServer_CreateDownloadLocation struct

+ func (_m DataProxyServiceServer_CreateDownloadLocation) Return(_a0 *service.CreateDownloadLocationResponse, _a1 error) *DataProxyServiceServer_CreateDownloadLocation

+ type DataProxyServiceServer_CreateUploadLocation struct

+ func (_m DataProxyServiceServer_CreateUploadLocation) Return(_a0 *service.CreateUploadLocationResponse, _a1 error) *DataProxyServiceServer_CreateUploadLocation

+ type DataProxyServiceServer_GetData struct

+ func (_m DataProxyServiceServer_GetData) Return(_a0 *service.GetDataResponse, _a1 error) *DataProxyServiceServer_GetData

+ type ExternalPluginServiceClient struct

+ func (_m *ExternalPluginServiceClient) CreateTask(ctx context.Context, in *service.TaskCreateRequest, opts ...grpc.CallOption) (*service.TaskCreateResponse, error)

+ func (_m *ExternalPluginServiceClient) DeleteTask(ctx context.Context, in *service.TaskDeleteRequest, opts ...grpc.CallOption) (*service.TaskDeleteResponse, error)

+ func (_m *ExternalPluginServiceClient) GetTask(ctx context.Context, in *service.TaskGetRequest, opts ...grpc.CallOption) (*service.TaskGetResponse, error)

+ func (_m *ExternalPluginServiceClient) OnCreateTask(ctx context.Context, in *service.TaskCreateRequest, opts ...grpc.CallOption) *ExternalPluginServiceClient_CreateTask

+ func (_m *ExternalPluginServiceClient) OnCreateTaskMatch(matchers ...interface{}) *ExternalPluginServiceClient_CreateTask

+ func (_m *ExternalPluginServiceClient) OnDeleteTask(ctx context.Context, in *service.TaskDeleteRequest, opts ...grpc.CallOption) *ExternalPluginServiceClient_DeleteTask

+ func (_m *ExternalPluginServiceClient) OnDeleteTaskMatch(matchers ...interface{}) *ExternalPluginServiceClient_DeleteTask

+ func (_m *ExternalPluginServiceClient) OnGetTask(ctx context.Context, in *service.TaskGetRequest, opts ...grpc.CallOption) *ExternalPluginServiceClient_GetTask

+ func (_m *ExternalPluginServiceClient) OnGetTaskMatch(matchers ...interface{}) *ExternalPluginServiceClient_GetTask

+ type ExternalPluginServiceClient_CreateTask struct

+ func (_m ExternalPluginServiceClient_CreateTask) Return(_a0 *service.TaskCreateResponse, _a1 error) *ExternalPluginServiceClient_CreateTask

+ type ExternalPluginServiceClient_DeleteTask struct

+ func (_m ExternalPluginServiceClient_DeleteTask) Return(_a0 *service.TaskDeleteResponse, _a1 error) *ExternalPluginServiceClient_DeleteTask

+ type ExternalPluginServiceClient_GetTask struct

+ func (_m ExternalPluginServiceClient_GetTask) Return(_a0 *service.TaskGetResponse, _a1 error) *ExternalPluginServiceClient_GetTask

+ type ExternalPluginServiceServer struct

+ func (_m *ExternalPluginServiceServer) CreateTask(_a0 context.Context, _a1 *service.TaskCreateRequest) (*service.TaskCreateResponse, error)

+ func (_m *ExternalPluginServiceServer) DeleteTask(_a0 context.Context, _a1 *service.TaskDeleteRequest) (*service.TaskDeleteResponse, error)

+ func (_m *ExternalPluginServiceServer) GetTask(_a0 context.Context, _a1 *service.TaskGetRequest) (*service.TaskGetResponse, error)

+ func (_m *ExternalPluginServiceServer) OnCreateTask(_a0 context.Context, _a1 *service.TaskCreateRequest) *ExternalPluginServiceServer_CreateTask

+ func (_m *ExternalPluginServiceServer) OnCreateTaskMatch(matchers ...interface{}) *ExternalPluginServiceServer_CreateTask

+ func (_m *ExternalPluginServiceServer) OnDeleteTask(_a0 context.Context, _a1 *service.TaskDeleteRequest) *ExternalPluginServiceServer_DeleteTask

+ func (_m *ExternalPluginServiceServer) OnDeleteTaskMatch(matchers ...interface{}) *ExternalPluginServiceServer_DeleteTask

+ func (_m *ExternalPluginServiceServer) OnGetTask(_a0 context.Context, _a1 *service.TaskGetRequest) *ExternalPluginServiceServer_GetTask

+ func (_m *ExternalPluginServiceServer) OnGetTaskMatch(matchers ...interface{}) *ExternalPluginServiceServer_GetTask

+ type ExternalPluginServiceServer_CreateTask struct

+ func (_m ExternalPluginServiceServer_CreateTask) Return(_a0 *service.TaskCreateResponse, _a1 error) *ExternalPluginServiceServer_CreateTask

+ type ExternalPluginServiceServer_DeleteTask struct

+ func (_m ExternalPluginServiceServer_DeleteTask) Return(_a0 *service.TaskDeleteResponse, _a1 error) *ExternalPluginServiceServer_DeleteTask

+ type ExternalPluginServiceServer_GetTask struct

+ func (_m ExternalPluginServiceServer_GetTask) Return(_a0 *service.TaskGetResponse, _a1 error) *ExternalPluginServiceServer_GetTask

+ type IdentityServiceClient struct

+ func (_m *IdentityServiceClient) OnUserInfo(ctx context.Context, in *service.UserInfoRequest, opts ...grpc.CallOption) *IdentityServiceClient_UserInfo

+ func (_m *IdentityServiceClient) OnUserInfoMatch(matchers ...interface{}) *IdentityServiceClient_UserInfo

+ func (_m *IdentityServiceClient) UserInfo(ctx context.Context, in *service.UserInfoRequest, opts ...grpc.CallOption) (*service.UserInfoResponse, error)

+ type IdentityServiceClient_UserInfo struct

+ func (_m IdentityServiceClient_UserInfo) Return(_a0 *service.UserInfoResponse, _a1 error) *IdentityServiceClient_UserInfo

+ type IdentityServiceServer struct

+ func (_m *IdentityServiceServer) OnUserInfo(_a0 context.Context, _a1 *service.UserInfoRequest) *IdentityServiceServer_UserInfo

+ func (_m *IdentityServiceServer) OnUserInfoMatch(matchers ...interface{}) *IdentityServiceServer_UserInfo

+ func (_m *IdentityServiceServer) UserInfo(_a0 context.Context, _a1 *service.UserInfoRequest) (*service.UserInfoResponse, error)

+ type IdentityServiceServer_UserInfo struct

+ func (_m IdentityServiceServer_UserInfo) Return(_a0 *service.UserInfoResponse, _a1 error) *IdentityServiceServer_UserInfo

+ type SignalServiceClient struct

+ func (_m *SignalServiceClient) GetOrCreateSignal(ctx context.Context, in *admin.SignalGetOrCreateRequest, ...) (*admin.Signal, error)

+ func (_m *SignalServiceClient) ListSignals(ctx context.Context, in *admin.SignalListRequest, opts ...grpc.CallOption) (*admin.SignalList, error)

+ func (_m *SignalServiceClient) OnGetOrCreateSignal(ctx context.Context, in *admin.SignalGetOrCreateRequest, ...) *SignalServiceClient_GetOrCreateSignal

+ func (_m *SignalServiceClient) OnGetOrCreateSignalMatch(matchers ...interface{}) *SignalServiceClient_GetOrCreateSignal

+ func (_m *SignalServiceClient) OnListSignals(ctx context.Context, in *admin.SignalListRequest, opts ...grpc.CallOption) *SignalServiceClient_ListSignals

+ func (_m *SignalServiceClient) OnListSignalsMatch(matchers ...interface{}) *SignalServiceClient_ListSignals

+ func (_m *SignalServiceClient) OnSetSignal(ctx context.Context, in *admin.SignalSetRequest, opts ...grpc.CallOption) *SignalServiceClient_SetSignal

+ func (_m *SignalServiceClient) OnSetSignalMatch(matchers ...interface{}) *SignalServiceClient_SetSignal

+ func (_m *SignalServiceClient) SetSignal(ctx context.Context, in *admin.SignalSetRequest, opts ...grpc.CallOption) (*admin.SignalSetResponse, error)

+ type SignalServiceClient_GetOrCreateSignal struct

+ func (_m SignalServiceClient_GetOrCreateSignal) Return(_a0 *admin.Signal, _a1 error) *SignalServiceClient_GetOrCreateSignal

+ type SignalServiceClient_ListSignals struct

+ func (_m SignalServiceClient_ListSignals) Return(_a0 *admin.SignalList, _a1 error) *SignalServiceClient_ListSignals

+ type SignalServiceClient_SetSignal struct

+ func (_m SignalServiceClient_SetSignal) Return(_a0 *admin.SignalSetResponse, _a1 error) *SignalServiceClient_SetSignal

+ type SignalServiceServer struct

+ func (_m *SignalServiceServer) GetOrCreateSignal(_a0 context.Context, _a1 *admin.SignalGetOrCreateRequest) (*admin.Signal, error)

+ func (_m *SignalServiceServer) ListSignals(_a0 context.Context, _a1 *admin.SignalListRequest) (*admin.SignalList, error)

+ func (_m *SignalServiceServer) OnGetOrCreateSignal(_a0 context.Context, _a1 *admin.SignalGetOrCreateRequest) *SignalServiceServer_GetOrCreateSignal

+ func (_m *SignalServiceServer) OnGetOrCreateSignalMatch(matchers ...interface{}) *SignalServiceServer_GetOrCreateSignal

+ func (_m *SignalServiceServer) OnListSignals(_a0 context.Context, _a1 *admin.SignalListRequest) *SignalServiceServer_ListSignals

+ func (_m *SignalServiceServer) OnListSignalsMatch(matchers ...interface{}) *SignalServiceServer_ListSignals

+ func (_m *SignalServiceServer) OnSetSignal(_a0 context.Context, _a1 *admin.SignalSetRequest) *SignalServiceServer_SetSignal

+ func (_m *SignalServiceServer) OnSetSignalMatch(matchers ...interface{}) *SignalServiceServer_SetSignal

+ func (_m *SignalServiceServer) SetSignal(_a0 context.Context, _a1 *admin.SignalSetRequest) (*admin.SignalSetResponse, error)

+ type SignalServiceServer_GetOrCreateSignal struct

+ func (_m SignalServiceServer_GetOrCreateSignal) Return(_a0 *admin.Signal, _a1 error) *SignalServiceServer_GetOrCreateSignal

+ type SignalServiceServer_ListSignals struct

+ func (_m SignalServiceServer_ListSignals) Return(_a0 *admin.SignalList, _a1 error) *SignalServiceServer_ListSignals

+ type SignalServiceServer_SetSignal struct

+ func (_m SignalServiceServer_SetSignal) Return(_a0 *admin.SignalSetResponse, _a1 error) *SignalServiceServer_SetSignal

+ type TokenSource struct

+ func (_m *TokenSource) OnToken() *TokenSource_Token

+ func (_m *TokenSource) OnTokenMatch(matchers ...interface{}) *TokenSource_Token

+ func (_m *TokenSource) Token() (*oauth2.Token, error)

+ type TokenSource_Token struct

+ func (_m TokenSource_Token) Return(_a0 *oauth2.Token, _a1 error) *TokenSource_Token

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL