pps_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc             v4.23.4
// source: pps/pps.proto

package pps

import (
	context "context"
	task "github.com/pachyderm/pachyderm/v2/src/task"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7

const (
	API_InspectJob_FullMethodName         = "/pps_v2.API/InspectJob"
	API_InspectJobSet_FullMethodName      = "/pps_v2.API/InspectJobSet"
	API_ListJob_FullMethodName            = "/pps_v2.API/ListJob"
	API_ListJobSet_FullMethodName         = "/pps_v2.API/ListJobSet"
	API_SubscribeJob_FullMethodName       = "/pps_v2.API/SubscribeJob"
	API_DeleteJob_FullMethodName          = "/pps_v2.API/DeleteJob"
	API_StopJob_FullMethodName            = "/pps_v2.API/StopJob"
	API_InspectDatum_FullMethodName       = "/pps_v2.API/InspectDatum"
	API_ListDatum_FullMethodName          = "/pps_v2.API/ListDatum"
	API_RestartDatum_FullMethodName       = "/pps_v2.API/RestartDatum"
	API_CreatePipeline_FullMethodName     = "/pps_v2.API/CreatePipeline"
	API_InspectPipeline_FullMethodName    = "/pps_v2.API/InspectPipeline"
	API_ListPipeline_FullMethodName       = "/pps_v2.API/ListPipeline"
	API_DeletePipeline_FullMethodName     = "/pps_v2.API/DeletePipeline"
	API_DeletePipelines_FullMethodName    = "/pps_v2.API/DeletePipelines"
	API_StartPipeline_FullMethodName      = "/pps_v2.API/StartPipeline"
	API_StopPipeline_FullMethodName       = "/pps_v2.API/StopPipeline"
	API_RunPipeline_FullMethodName        = "/pps_v2.API/RunPipeline"
	API_RunCron_FullMethodName            = "/pps_v2.API/RunCron"
	API_CreateSecret_FullMethodName       = "/pps_v2.API/CreateSecret"
	API_DeleteSecret_FullMethodName       = "/pps_v2.API/DeleteSecret"
	API_ListSecret_FullMethodName         = "/pps_v2.API/ListSecret"
	API_InspectSecret_FullMethodName      = "/pps_v2.API/InspectSecret"
	API_DeleteAll_FullMethodName          = "/pps_v2.API/DeleteAll"
	API_GetLogs_FullMethodName            = "/pps_v2.API/GetLogs"
	API_ActivateAuth_FullMethodName       = "/pps_v2.API/ActivateAuth"
	API_UpdateJobState_FullMethodName     = "/pps_v2.API/UpdateJobState"
	API_RunLoadTest_FullMethodName        = "/pps_v2.API/RunLoadTest"
	API_RunLoadTestDefault_FullMethodName = "/pps_v2.API/RunLoadTestDefault"
	API_RenderTemplate_FullMethodName     = "/pps_v2.API/RenderTemplate"
	API_ListTask_FullMethodName           = "/pps_v2.API/ListTask"
	API_GetKubeEvents_FullMethodName      = "/pps_v2.API/GetKubeEvents"
	API_QueryLoki_FullMethodName          = "/pps_v2.API/QueryLoki"
)

// APIClient is the client API for API service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type APIClient interface {
	InspectJob(ctx context.Context, in *InspectJobRequest, opts ...grpc.CallOption) (*JobInfo, error)
	InspectJobSet(ctx context.Context, in *InspectJobSetRequest, opts ...grpc.CallOption) (API_InspectJobSetClient, error)
	// ListJob returns information about current and past Pachyderm jobs.
	ListJob(ctx context.Context, in *ListJobRequest, opts ...grpc.CallOption) (API_ListJobClient, error)
	ListJobSet(ctx context.Context, in *ListJobSetRequest, opts ...grpc.CallOption) (API_ListJobSetClient, error)
	SubscribeJob(ctx context.Context, in *SubscribeJobRequest, opts ...grpc.CallOption) (API_SubscribeJobClient, error)
	DeleteJob(ctx context.Context, in *DeleteJobRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	StopJob(ctx context.Context, in *StopJobRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	InspectDatum(ctx context.Context, in *InspectDatumRequest, opts ...grpc.CallOption) (*DatumInfo, error)
	// ListDatum returns information about each datum fed to a Pachyderm job
	ListDatum(ctx context.Context, in *ListDatumRequest, opts ...grpc.CallOption) (API_ListDatumClient, error)
	RestartDatum(ctx context.Context, in *RestartDatumRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	CreatePipeline(ctx context.Context, in *CreatePipelineRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	InspectPipeline(ctx context.Context, in *InspectPipelineRequest, opts ...grpc.CallOption) (*PipelineInfo, error)
	ListPipeline(ctx context.Context, in *ListPipelineRequest, opts ...grpc.CallOption) (API_ListPipelineClient, error)
	DeletePipeline(ctx context.Context, in *DeletePipelineRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	DeletePipelines(ctx context.Context, in *DeletePipelinesRequest, opts ...grpc.CallOption) (*DeletePipelinesResponse, error)
	StartPipeline(ctx context.Context, in *StartPipelineRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	StopPipeline(ctx context.Context, in *StopPipelineRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	RunPipeline(ctx context.Context, in *RunPipelineRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	RunCron(ctx context.Context, in *RunCronRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	CreateSecret(ctx context.Context, in *CreateSecretRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	DeleteSecret(ctx context.Context, in *DeleteSecretRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	ListSecret(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*SecretInfos, error)
	InspectSecret(ctx context.Context, in *InspectSecretRequest, opts ...grpc.CallOption) (*SecretInfo, error)
	// DeleteAll deletes everything
	DeleteAll(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetLogs(ctx context.Context, in *GetLogsRequest, opts ...grpc.CallOption) (API_GetLogsClient, error)
	// An internal call that causes PPS to put itself into an auth-enabled state
	// (all pipeline have tokens, correct permissions, etcd)
	ActivateAuth(ctx context.Context, in *ActivateAuthRequest, opts ...grpc.CallOption) (*ActivateAuthResponse, error)
	// An internal call used to move a job from one state to another
	UpdateJobState(ctx context.Context, in *UpdateJobStateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// RunLoadTest runs a load test.
	RunLoadTest(ctx context.Context, in *RunLoadTestRequest, opts ...grpc.CallOption) (*RunLoadTestResponse, error)
	// RunLoadTestDefault runs the default load test.
	RunLoadTestDefault(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*RunLoadTestResponse, error)
	// RenderTemplate renders the provided template and arguments into a list of Pipeline specicifications
	RenderTemplate(ctx context.Context, in *RenderTemplateRequest, opts ...grpc.CallOption) (*RenderTemplateResponse, error)
	// ListTask lists PPS tasks
	ListTask(ctx context.Context, in *task.ListTaskRequest, opts ...grpc.CallOption) (API_ListTaskClient, error)
	// GetKubeEvents returns a stream of kubernetes events
	GetKubeEvents(ctx context.Context, in *LokiRequest, opts ...grpc.CallOption) (API_GetKubeEventsClient, error)
	// QueryLoki returns a stream of loki log messages given a query string
	QueryLoki(ctx context.Context, in *LokiRequest, opts ...grpc.CallOption) (API_QueryLokiClient, error)
}

type aPIClient struct {
	cc grpc.ClientConnInterface
}

func NewAPIClient(cc grpc.ClientConnInterface) APIClient {
	return &aPIClient{cc}
}

func (c *aPIClient) InspectJob(ctx context.Context, in *InspectJobRequest, opts ...grpc.CallOption) (*JobInfo, error) {
	out := new(JobInfo)
	err := c.cc.Invoke(ctx, API_InspectJob_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) InspectJobSet(ctx context.Context, in *InspectJobSetRequest, opts ...grpc.CallOption) (API_InspectJobSetClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[0], API_InspectJobSet_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPIInspectJobSetClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type API_InspectJobSetClient interface {
	Recv() (*JobInfo, error)
	grpc.ClientStream
}

type aPIInspectJobSetClient struct {
	grpc.ClientStream
}

func (x *aPIInspectJobSetClient) Recv() (*JobInfo, error) {
	m := new(JobInfo)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *aPIClient) ListJob(ctx context.Context, in *ListJobRequest, opts ...grpc.CallOption) (API_ListJobClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[1], API_ListJob_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPIListJobClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type API_ListJobClient interface {
	Recv() (*JobInfo, error)
	grpc.ClientStream
}

type aPIListJobClient struct {
	grpc.ClientStream
}

func (x *aPIListJobClient) Recv() (*JobInfo, error) {
	m := new(JobInfo)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *aPIClient) ListJobSet(ctx context.Context, in *ListJobSetRequest, opts ...grpc.CallOption) (API_ListJobSetClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[2], API_ListJobSet_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPIListJobSetClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type API_ListJobSetClient interface {
	Recv() (*JobSetInfo, error)
	grpc.ClientStream
}

type aPIListJobSetClient struct {
	grpc.ClientStream
}

func (x *aPIListJobSetClient) Recv() (*JobSetInfo, error) {
	m := new(JobSetInfo)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *aPIClient) SubscribeJob(ctx context.Context, in *SubscribeJobRequest, opts ...grpc.CallOption) (API_SubscribeJobClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[3], API_SubscribeJob_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPISubscribeJobClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type API_SubscribeJobClient interface {
	Recv() (*JobInfo, error)
	grpc.ClientStream
}

type aPISubscribeJobClient struct {
	grpc.ClientStream
}

func (x *aPISubscribeJobClient) Recv() (*JobInfo, error) {
	m := new(JobInfo)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *aPIClient) DeleteJob(ctx context.Context, in *DeleteJobRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, API_DeleteJob_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) StopJob(ctx context.Context, in *StopJobRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, API_StopJob_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) InspectDatum(ctx context.Context, in *InspectDatumRequest, opts ...grpc.CallOption) (*DatumInfo, error) {
	out := new(DatumInfo)
	err := c.cc.Invoke(ctx, API_InspectDatum_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) ListDatum(ctx context.Context, in *ListDatumRequest, opts ...grpc.CallOption) (API_ListDatumClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[4], API_ListDatum_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPIListDatumClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type API_ListDatumClient interface {
	Recv() (*DatumInfo, error)
	grpc.ClientStream
}

type aPIListDatumClient struct {
	grpc.ClientStream
}

func (x *aPIListDatumClient) Recv() (*DatumInfo, error) {
	m := new(DatumInfo)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *aPIClient) RestartDatum(ctx context.Context, in *RestartDatumRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, API_RestartDatum_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) CreatePipeline(ctx context.Context, in *CreatePipelineRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, API_CreatePipeline_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) InspectPipeline(ctx context.Context, in *InspectPipelineRequest, opts ...grpc.CallOption) (*PipelineInfo, error) {
	out := new(PipelineInfo)
	err := c.cc.Invoke(ctx, API_InspectPipeline_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) ListPipeline(ctx context.Context, in *ListPipelineRequest, opts ...grpc.CallOption) (API_ListPipelineClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[5], API_ListPipeline_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPIListPipelineClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type API_ListPipelineClient interface {
	Recv() (*PipelineInfo, error)
	grpc.ClientStream
}

type aPIListPipelineClient struct {
	grpc.ClientStream
}

func (x *aPIListPipelineClient) Recv() (*PipelineInfo, error) {
	m := new(PipelineInfo)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *aPIClient) DeletePipeline(ctx context.Context, in *DeletePipelineRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, API_DeletePipeline_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) DeletePipelines(ctx context.Context, in *DeletePipelinesRequest, opts ...grpc.CallOption) (*DeletePipelinesResponse, error) {
	out := new(DeletePipelinesResponse)
	err := c.cc.Invoke(ctx, API_DeletePipelines_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) StartPipeline(ctx context.Context, in *StartPipelineRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, API_StartPipeline_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) StopPipeline(ctx context.Context, in *StopPipelineRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, API_StopPipeline_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) RunPipeline(ctx context.Context, in *RunPipelineRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, API_RunPipeline_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) RunCron(ctx context.Context, in *RunCronRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, API_RunCron_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) CreateSecret(ctx context.Context, in *CreateSecretRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, API_CreateSecret_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) DeleteSecret(ctx context.Context, in *DeleteSecretRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, API_DeleteSecret_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) ListSecret(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*SecretInfos, error) {
	out := new(SecretInfos)
	err := c.cc.Invoke(ctx, API_ListSecret_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) InspectSecret(ctx context.Context, in *InspectSecretRequest, opts ...grpc.CallOption) (*SecretInfo, error) {
	out := new(SecretInfo)
	err := c.cc.Invoke(ctx, API_InspectSecret_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) DeleteAll(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, API_DeleteAll_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) GetLogs(ctx context.Context, in *GetLogsRequest, opts ...grpc.CallOption) (API_GetLogsClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[6], API_GetLogs_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPIGetLogsClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type API_GetLogsClient interface {
	Recv() (*LogMessage, error)
	grpc.ClientStream
}

type aPIGetLogsClient struct {
	grpc.ClientStream
}

func (x *aPIGetLogsClient) Recv() (*LogMessage, error) {
	m := new(LogMessage)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *aPIClient) ActivateAuth(ctx context.Context, in *ActivateAuthRequest, opts ...grpc.CallOption) (*ActivateAuthResponse, error) {
	out := new(ActivateAuthResponse)
	err := c.cc.Invoke(ctx, API_ActivateAuth_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) UpdateJobState(ctx context.Context, in *UpdateJobStateRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, API_UpdateJobState_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) RunLoadTest(ctx context.Context, in *RunLoadTestRequest, opts ...grpc.CallOption) (*RunLoadTestResponse, error) {
	out := new(RunLoadTestResponse)
	err := c.cc.Invoke(ctx, API_RunLoadTest_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) RunLoadTestDefault(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*RunLoadTestResponse, error) {
	out := new(RunLoadTestResponse)
	err := c.cc.Invoke(ctx, API_RunLoadTestDefault_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) RenderTemplate(ctx context.Context, in *RenderTemplateRequest, opts ...grpc.CallOption) (*RenderTemplateResponse, error) {
	out := new(RenderTemplateResponse)
	err := c.cc.Invoke(ctx, API_RenderTemplate_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) ListTask(ctx context.Context, in *task.ListTaskRequest, opts ...grpc.CallOption) (API_ListTaskClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[7], API_ListTask_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPIListTaskClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type API_ListTaskClient interface {
	Recv() (*task.TaskInfo, error)
	grpc.ClientStream
}

type aPIListTaskClient struct {
	grpc.ClientStream
}

func (x *aPIListTaskClient) Recv() (*task.TaskInfo, error) {
	m := new(task.TaskInfo)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *aPIClient) GetKubeEvents(ctx context.Context, in *LokiRequest, opts ...grpc.CallOption) (API_GetKubeEventsClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[8], API_GetKubeEvents_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPIGetKubeEventsClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type API_GetKubeEventsClient interface {
	Recv() (*LokiLogMessage, error)
	grpc.ClientStream
}

type aPIGetKubeEventsClient struct {
	grpc.ClientStream
}

func (x *aPIGetKubeEventsClient) Recv() (*LokiLogMessage, error) {
	m := new(LokiLogMessage)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *aPIClient) QueryLoki(ctx context.Context, in *LokiRequest, opts ...grpc.CallOption) (API_QueryLokiClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[9], API_QueryLoki_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPIQueryLokiClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type API_QueryLokiClient interface {
	Recv() (*LokiLogMessage, error)
	grpc.ClientStream
}

type aPIQueryLokiClient struct {
	grpc.ClientStream
}

func (x *aPIQueryLokiClient) Recv() (*LokiLogMessage, error) {
	m := new(LokiLogMessage)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// APIServer is the server API for API service.
// All implementations must embed UnimplementedAPIServer
// for forward compatibility
type APIServer interface {
	InspectJob(context.Context, *InspectJobRequest) (*JobInfo, error)
	InspectJobSet(*InspectJobSetRequest, API_InspectJobSetServer) error
	// ListJob returns information about current and past Pachyderm jobs.
	ListJob(*ListJobRequest, API_ListJobServer) error
	ListJobSet(*ListJobSetRequest, API_ListJobSetServer) error
	SubscribeJob(*SubscribeJobRequest, API_SubscribeJobServer) error
	DeleteJob(context.Context, *DeleteJobRequest) (*emptypb.Empty, error)
	StopJob(context.Context, *StopJobRequest) (*emptypb.Empty, error)
	InspectDatum(context.Context, *InspectDatumRequest) (*DatumInfo, error)
	// ListDatum returns information about each datum fed to a Pachyderm job
	ListDatum(*ListDatumRequest, API_ListDatumServer) error
	RestartDatum(context.Context, *RestartDatumRequest) (*emptypb.Empty, error)
	CreatePipeline(context.Context, *CreatePipelineRequest) (*emptypb.Empty, error)
	InspectPipeline(context.Context, *InspectPipelineRequest) (*PipelineInfo, error)
	ListPipeline(*ListPipelineRequest, API_ListPipelineServer) error
	DeletePipeline(context.Context, *DeletePipelineRequest) (*emptypb.Empty, error)
	DeletePipelines(context.Context, *DeletePipelinesRequest) (*DeletePipelinesResponse, error)
	StartPipeline(context.Context, *StartPipelineRequest) (*emptypb.Empty, error)
	StopPipeline(context.Context, *StopPipelineRequest) (*emptypb.Empty, error)
	RunPipeline(context.Context, *RunPipelineRequest) (*emptypb.Empty, error)
	RunCron(context.Context, *RunCronRequest) (*emptypb.Empty, error)
	CreateSecret(context.Context, *CreateSecretRequest) (*emptypb.Empty, error)
	DeleteSecret(context.Context, *DeleteSecretRequest) (*emptypb.Empty, error)
	ListSecret(context.Context, *emptypb.Empty) (*SecretInfos, error)
	InspectSecret(context.Context, *InspectSecretRequest) (*SecretInfo, error)
	// DeleteAll deletes everything
	DeleteAll(context.Context, *emptypb.Empty) (*emptypb.Empty, error)
	GetLogs(*GetLogsRequest, API_GetLogsServer) error
	// An internal call that causes PPS to put itself into an auth-enabled state
	// (all pipeline have tokens, correct permissions, etcd)
	ActivateAuth(context.Context, *ActivateAuthRequest) (*ActivateAuthResponse, error)
	// An internal call used to move a job from one state to another
	UpdateJobState(context.Context, *UpdateJobStateRequest) (*emptypb.Empty, error)
	// RunLoadTest runs a load test.
	RunLoadTest(context.Context, *RunLoadTestRequest) (*RunLoadTestResponse, error)
	// RunLoadTestDefault runs the default load test.
	RunLoadTestDefault(context.Context, *emptypb.Empty) (*RunLoadTestResponse, error)
	// RenderTemplate renders the provided template and arguments into a list of Pipeline specicifications
	RenderTemplate(context.Context, *RenderTemplateRequest) (*RenderTemplateResponse, error)
	// ListTask lists PPS tasks
	ListTask(*task.ListTaskRequest, API_ListTaskServer) error
	// GetKubeEvents returns a stream of kubernetes events
	GetKubeEvents(*LokiRequest, API_GetKubeEventsServer) error
	// QueryLoki returns a stream of loki log messages given a query string
	QueryLoki(*LokiRequest, API_QueryLokiServer) error
	mustEmbedUnimplementedAPIServer()
}

// UnimplementedAPIServer must be embedded to have forward compatible implementations.
type UnimplementedAPIServer struct {
}

func (UnimplementedAPIServer) InspectJob(context.Context, *InspectJobRequest) (*JobInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InspectJob not implemented")
}
func (UnimplementedAPIServer) InspectJobSet(*InspectJobSetRequest, API_InspectJobSetServer) error {
	return status.Errorf(codes.Unimplemented, "method InspectJobSet not implemented")
}
func (UnimplementedAPIServer) ListJob(*ListJobRequest, API_ListJobServer) error {
	return status.Errorf(codes.Unimplemented, "method ListJob not implemented")
}
func (UnimplementedAPIServer) ListJobSet(*ListJobSetRequest, API_ListJobSetServer) error {
	return status.Errorf(codes.Unimplemented, "method ListJobSet not implemented")
}
func (UnimplementedAPIServer) SubscribeJob(*SubscribeJobRequest, API_SubscribeJobServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeJob not implemented")
}
func (UnimplementedAPIServer) DeleteJob(context.Context, *DeleteJobRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteJob not implemented")
}
func (UnimplementedAPIServer) StopJob(context.Context, *StopJobRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StopJob not implemented")
}
func (UnimplementedAPIServer) InspectDatum(context.Context, *InspectDatumRequest) (*DatumInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InspectDatum not implemented")
}
func (UnimplementedAPIServer) ListDatum(*ListDatumRequest, API_ListDatumServer) error {
	return status.Errorf(codes.Unimplemented, "method ListDatum not implemented")
}
func (UnimplementedAPIServer) RestartDatum(context.Context, *RestartDatumRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RestartDatum not implemented")
}
func (UnimplementedAPIServer) CreatePipeline(context.Context, *CreatePipelineRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreatePipeline not implemented")
}
func (UnimplementedAPIServer) InspectPipeline(context.Context, *InspectPipelineRequest) (*PipelineInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InspectPipeline not implemented")
}
func (UnimplementedAPIServer) ListPipeline(*ListPipelineRequest, API_ListPipelineServer) error {
	return status.Errorf(codes.Unimplemented, "method ListPipeline not implemented")
}
func (UnimplementedAPIServer) DeletePipeline(context.Context, *DeletePipelineRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeletePipeline not implemented")
}
func (UnimplementedAPIServer) DeletePipelines(context.Context, *DeletePipelinesRequest) (*DeletePipelinesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeletePipelines not implemented")
}
func (UnimplementedAPIServer) StartPipeline(context.Context, *StartPipelineRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartPipeline not implemented")
}
func (UnimplementedAPIServer) StopPipeline(context.Context, *StopPipelineRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StopPipeline not implemented")
}
func (UnimplementedAPIServer) RunPipeline(context.Context, *RunPipelineRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunPipeline not implemented")
}
func (UnimplementedAPIServer) RunCron(context.Context, *RunCronRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunCron not implemented")
}
func (UnimplementedAPIServer) CreateSecret(context.Context, *CreateSecretRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateSecret not implemented")
}
func (UnimplementedAPIServer) DeleteSecret(context.Context, *DeleteSecretRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteSecret not implemented")
}
func (UnimplementedAPIServer) ListSecret(context.Context, *emptypb.Empty) (*SecretInfos, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListSecret not implemented")
}
func (UnimplementedAPIServer) InspectSecret(context.Context, *InspectSecretRequest) (*SecretInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InspectSecret not implemented")
}
func (UnimplementedAPIServer) DeleteAll(context.Context, *emptypb.Empty) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteAll not implemented")
}
func (UnimplementedAPIServer) GetLogs(*GetLogsRequest, API_GetLogsServer) error {
	return status.Errorf(codes.Unimplemented, "method GetLogs not implemented")
}
func (UnimplementedAPIServer) ActivateAuth(context.Context, *ActivateAuthRequest) (*ActivateAuthResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ActivateAuth not implemented")
}
func (UnimplementedAPIServer) UpdateJobState(context.Context, *UpdateJobStateRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateJobState not implemented")
}
func (UnimplementedAPIServer) RunLoadTest(context.Context, *RunLoadTestRequest) (*RunLoadTestResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunLoadTest not implemented")
}
func (UnimplementedAPIServer) RunLoadTestDefault(context.Context, *emptypb.Empty) (*RunLoadTestResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RunLoadTestDefault not implemented")
}
func (UnimplementedAPIServer) RenderTemplate(context.Context, *RenderTemplateRequest) (*RenderTemplateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RenderTemplate not implemented")
}
func (UnimplementedAPIServer) ListTask(*task.ListTaskRequest, API_ListTaskServer) error {
	return status.Errorf(codes.Unimplemented, "method ListTask not implemented")
}
func (UnimplementedAPIServer) GetKubeEvents(*LokiRequest, API_GetKubeEventsServer) error {
	return status.Errorf(codes.Unimplemented, "method GetKubeEvents not implemented")
}
func (UnimplementedAPIServer) QueryLoki(*LokiRequest, API_QueryLokiServer) error {
	return status.Errorf(codes.Unimplemented, "method QueryLoki not implemented")
}
func (UnimplementedAPIServer) mustEmbedUnimplementedAPIServer() {}

// UnsafeAPIServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to APIServer will
// result in compilation errors.
type UnsafeAPIServer interface {
	mustEmbedUnimplementedAPIServer()
}

func RegisterAPIServer(s grpc.ServiceRegistrar, srv APIServer) {
	s.RegisterService(&API_ServiceDesc, srv)
}

func _API_InspectJob_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InspectJobRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(APIServer).InspectJob(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: API_InspectJob_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(APIServer).InspectJob(ctx, req.(*InspectJobRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _API_InspectJobSet_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(InspectJobSetRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).InspectJobSet(m, &aPIInspectJobSetServer{stream})
}

type API_InspectJobSetServer interface {
	Send(*JobInfo) error
	grpc.ServerStream
}

type aPIInspectJobSetServer struct {
	grpc.ServerStream
}

func (x *aPIInspectJobSetServer) Send(m *JobInfo) error {
	return x.ServerStream.SendMsg(m)
}

func _API_ListJob_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListJobRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).ListJob(m, &aPIListJobServer{stream})
}

type API_ListJobServer interface {
	Send(*JobInfo) error
	grpc.ServerStream
}

type aPIListJobServer struct {
	grpc.ServerStream
}

func (x *aPIListJobServer) Send(m *JobInfo) error {
	return x.ServerStream.SendMsg(m)
}

func _API_ListJobSet_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListJobSetRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).ListJobSet(m, &aPIListJobSetServer{stream})
}

type API_ListJobSetServer interface {
	Send(*JobSetInfo) error
	grpc.ServerStream
}

type aPIListJobSetServer struct {
	grpc.ServerStream
}

func (x *aPIListJobSetServer) Send(m *JobSetInfo) error {
	return x.ServerStream.SendMsg(m)
}

func _API_SubscribeJob_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SubscribeJobRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).SubscribeJob(m, &aPISubscribeJobServer{stream})
}

type API_SubscribeJobServer interface {
	Send(*JobInfo) error
	grpc.ServerStream
}

type aPISubscribeJobServer struct {
	grpc.ServerStream
}

func (x *aPISubscribeJobServer) Send(m *JobInfo) error {
	return x.ServerStream.SendMsg(m)
}

func _API_DeleteJob_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteJobRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(APIServer).DeleteJob(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: API_DeleteJob_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(APIServer).DeleteJob(ctx, req.(*DeleteJobRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _API_StopJob_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StopJobRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(APIServer).StopJob(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: API_StopJob_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(APIServer).StopJob(ctx, req.(*StopJobRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _API_InspectDatum_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InspectDatumRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(APIServer).InspectDatum(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: API_InspectDatum_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(APIServer).InspectDatum(ctx, req.(*InspectDatumRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _API_ListDatum_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListDatumRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).ListDatum(m, &aPIListDatumServer{stream})
}

type API_ListDatumServer interface {
	Send(*DatumInfo) error
	grpc.ServerStream
}

type aPIListDatumServer struct {
	grpc.ServerStream
}

func (x *aPIListDatumServer) Send(m *DatumInfo) error {
	return x.ServerStream.SendMsg(m)
}

func _API_RestartDatum_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RestartDatumRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(APIServer).RestartDatum(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: API_RestartDatum_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(APIServer).RestartDatum(ctx, req.(*RestartDatumRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _API_CreatePipeline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreatePipelineRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(APIServer).CreatePipeline(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: API_CreatePipeline_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(APIServer).CreatePipeline(ctx, req.(*CreatePipelineRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _API_InspectPipeline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InspectPipelineRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(APIServer).InspectPipeline(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: API_InspectPipeline_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(APIServer).InspectPipeline(ctx, req.(*InspectPipelineRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _API_ListPipeline_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListPipelineRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).ListPipeline(m, &aPIListPipelineServer{stream})
}

type API_ListPipelineServer interface {
	Send(*PipelineInfo) error
	grpc.ServerStream
}

type aPIListPipelineServer struct {
	grpc.ServerStream
}

func (x *aPIListPipelineServer) Send(m *PipelineInfo) error {
	return x.ServerStream.SendMsg(m)
}

func _API_DeletePipeline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeletePipelineRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(APIServer).DeletePipeline(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: API_DeletePipeline_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(APIServer).DeletePipeline(ctx, req.(*DeletePipelineRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _API_DeletePipelines_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeletePipelinesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(APIServer).DeletePipelines(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: API_DeletePipelines_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(APIServer).DeletePipelines(ctx, req.(*DeletePipelinesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _API_StartPipeline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StartPipelineRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(APIServer).StartPipeline(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: API_StartPipeline_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(APIServer).StartPipeline(ctx, req.(*StartPipelineRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _API_StopPipeline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StopPipelineRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(APIServer).StopPipeline(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: API_StopPipeline_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(APIServer).StopPipeline(ctx, req.(*StopPipelineRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _API_RunPipeline_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunPipelineRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(APIServer).RunPipeline(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: API_RunPipeline_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(APIServer).RunPipeline(ctx, req.(*RunPipelineRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _API_RunCron_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunCronRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(APIServer).RunCron(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: API_RunCron_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(APIServer).RunCron(ctx, req.(*RunCronRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _API_CreateSecret_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateSecretRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(APIServer).CreateSecret(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: API_CreateSecret_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(APIServer).CreateSecret(ctx, req.(*CreateSecretRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _API_DeleteSecret_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteSecretRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(APIServer).DeleteSecret(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: API_DeleteSecret_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(APIServer).DeleteSecret(ctx, req.(*DeleteSecretRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _API_ListSecret_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(APIServer).ListSecret(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: API_ListSecret_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(APIServer).ListSecret(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _API_InspectSecret_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InspectSecretRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(APIServer).InspectSecret(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: API_InspectSecret_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(APIServer).InspectSecret(ctx, req.(*InspectSecretRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _API_DeleteAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(APIServer).DeleteAll(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: API_DeleteAll_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(APIServer).DeleteAll(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _API_GetLogs_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetLogsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).GetLogs(m, &aPIGetLogsServer{stream})
}

type API_GetLogsServer interface {
	Send(*LogMessage) error
	grpc.ServerStream
}

type aPIGetLogsServer struct {
	grpc.ServerStream
}

func (x *aPIGetLogsServer) Send(m *LogMessage) error {
	return x.ServerStream.SendMsg(m)
}

func _API_ActivateAuth_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ActivateAuthRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(APIServer).ActivateAuth(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: API_ActivateAuth_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(APIServer).ActivateAuth(ctx, req.(*ActivateAuthRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _API_UpdateJobState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateJobStateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(APIServer).UpdateJobState(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: API_UpdateJobState_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(APIServer).UpdateJobState(ctx, req.(*UpdateJobStateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _API_RunLoadTest_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RunLoadTestRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(APIServer).RunLoadTest(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: API_RunLoadTest_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(APIServer).RunLoadTest(ctx, req.(*RunLoadTestRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _API_RunLoadTestDefault_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(APIServer).RunLoadTestDefault(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: API_RunLoadTestDefault_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(APIServer).RunLoadTestDefault(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _API_RenderTemplate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RenderTemplateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(APIServer).RenderTemplate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: API_RenderTemplate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(APIServer).RenderTemplate(ctx, req.(*RenderTemplateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _API_ListTask_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(task.ListTaskRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).ListTask(m, &aPIListTaskServer{stream})
}

type API_ListTaskServer interface {
	Send(*task.TaskInfo) error
	grpc.ServerStream
}

type aPIListTaskServer struct {
	grpc.ServerStream
}

func (x *aPIListTaskServer) Send(m *task.TaskInfo) error {
	return x.ServerStream.SendMsg(m)
}

func _API_GetKubeEvents_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(LokiRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).GetKubeEvents(m, &aPIGetKubeEventsServer{stream})
}

type API_GetKubeEventsServer interface {
	Send(*LokiLogMessage) error
	grpc.ServerStream
}

type aPIGetKubeEventsServer struct {
	grpc.ServerStream
}

func (x *aPIGetKubeEventsServer) Send(m *LokiLogMessage) error {
	return x.ServerStream.SendMsg(m)
}

func _API_QueryLoki_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(LokiRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).QueryLoki(m, &aPIQueryLokiServer{stream})
}

type API_QueryLokiServer interface {
	Send(*LokiLogMessage) error
	grpc.ServerStream
}

type aPIQueryLokiServer struct {
	grpc.ServerStream
}

func (x *aPIQueryLokiServer) Send(m *LokiLogMessage) error {
	return x.ServerStream.SendMsg(m)
}

// API_ServiceDesc is the grpc.ServiceDesc for API service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var API_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "pps_v2.API",
	HandlerType: (*APIServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "InspectJob",
			Handler:    _API_InspectJob_Handler,
		},
		{
			MethodName: "DeleteJob",
			Handler:    _API_DeleteJob_Handler,
		},
		{
			MethodName: "StopJob",
			Handler:    _API_StopJob_Handler,
		},
		{
			MethodName: "InspectDatum",
			Handler:    _API_InspectDatum_Handler,
		},
		{
			MethodName: "RestartDatum",
			Handler:    _API_RestartDatum_Handler,
		},
		{
			MethodName: "CreatePipeline",
			Handler:    _API_CreatePipeline_Handler,
		},
		{
			MethodName: "InspectPipeline",
			Handler:    _API_InspectPipeline_Handler,
		},
		{
			MethodName: "DeletePipeline",
			Handler:    _API_DeletePipeline_Handler,
		},
		{
			MethodName: "DeletePipelines",
			Handler:    _API_DeletePipelines_Handler,
		},
		{
			MethodName: "StartPipeline",
			Handler:    _API_StartPipeline_Handler,
		},
		{
			MethodName: "StopPipeline",
			Handler:    _API_StopPipeline_Handler,
		},
		{
			MethodName: "RunPipeline",
			Handler:    _API_RunPipeline_Handler,
		},
		{
			MethodName: "RunCron",
			Handler:    _API_RunCron_Handler,
		},
		{
			MethodName: "CreateSecret",
			Handler:    _API_CreateSecret_Handler,
		},
		{
			MethodName: "DeleteSecret",
			Handler:    _API_DeleteSecret_Handler,
		},
		{
			MethodName: "ListSecret",
			Handler:    _API_ListSecret_Handler,
		},
		{
			MethodName: "InspectSecret",
			Handler:    _API_InspectSecret_Handler,
		},
		{
			MethodName: "DeleteAll",
			Handler:    _API_DeleteAll_Handler,
		},
		{
			MethodName: "ActivateAuth",
			Handler:    _API_ActivateAuth_Handler,
		},
		{
			MethodName: "UpdateJobState",
			Handler:    _API_UpdateJobState_Handler,
		},
		{
			MethodName: "RunLoadTest",
			Handler:    _API_RunLoadTest_Handler,
		},
		{
			MethodName: "RunLoadTestDefault",
			Handler:    _API_RunLoadTestDefault_Handler,
		},
		{
			MethodName: "RenderTemplate",
			Handler:    _API_RenderTemplate_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "InspectJobSet",
			Handler:       _API_InspectJobSet_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListJob",
			Handler:       _API_ListJob_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListJobSet",
			Handler:       _API_ListJobSet_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeJob",
			Handler:       _API_SubscribeJob_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListDatum",
			Handler:       _API_ListDatum_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListPipeline",
			Handler:       _API_ListPipeline_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetLogs",
			Handler:       _API_GetLogs_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListTask",
			Handler:       _API_ListTask_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetKubeEvents",
			Handler:       _API_GetKubeEvents_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "QueryLoki",
			Handler:       _API_QueryLoki_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "pps/pps.proto",
}