pfs_grpc.pb.go

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

package pfs

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"
	wrapperspb "google.golang.org/protobuf/types/known/wrapperspb"
)

// 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_CreateRepo_FullMethodName           = "/pfs_v2.API/CreateRepo"
	API_InspectRepo_FullMethodName          = "/pfs_v2.API/InspectRepo"
	API_ListRepo_FullMethodName             = "/pfs_v2.API/ListRepo"
	API_DeleteRepo_FullMethodName           = "/pfs_v2.API/DeleteRepo"
	API_DeleteRepos_FullMethodName          = "/pfs_v2.API/DeleteRepos"
	API_StartCommit_FullMethodName          = "/pfs_v2.API/StartCommit"
	API_FinishCommit_FullMethodName         = "/pfs_v2.API/FinishCommit"
	API_ClearCommit_FullMethodName          = "/pfs_v2.API/ClearCommit"
	API_InspectCommit_FullMethodName        = "/pfs_v2.API/InspectCommit"
	API_ListCommit_FullMethodName           = "/pfs_v2.API/ListCommit"
	API_SubscribeCommit_FullMethodName      = "/pfs_v2.API/SubscribeCommit"
	API_SquashCommit_FullMethodName         = "/pfs_v2.API/SquashCommit"
	API_DropCommit_FullMethodName           = "/pfs_v2.API/DropCommit"
	API_InspectCommitSet_FullMethodName     = "/pfs_v2.API/InspectCommitSet"
	API_ListCommitSet_FullMethodName        = "/pfs_v2.API/ListCommitSet"
	API_SquashCommitSet_FullMethodName      = "/pfs_v2.API/SquashCommitSet"
	API_DropCommitSet_FullMethodName        = "/pfs_v2.API/DropCommitSet"
	API_FindCommits_FullMethodName          = "/pfs_v2.API/FindCommits"
	API_WalkCommitProvenance_FullMethodName = "/pfs_v2.API/WalkCommitProvenance"
	API_WalkCommitSubvenance_FullMethodName = "/pfs_v2.API/WalkCommitSubvenance"
	API_CreateBranch_FullMethodName         = "/pfs_v2.API/CreateBranch"
	API_InspectBranch_FullMethodName        = "/pfs_v2.API/InspectBranch"
	API_ListBranch_FullMethodName           = "/pfs_v2.API/ListBranch"
	API_DeleteBranch_FullMethodName         = "/pfs_v2.API/DeleteBranch"
	API_WalkBranchProvenance_FullMethodName = "/pfs_v2.API/WalkBranchProvenance"
	API_WalkBranchSubvenance_FullMethodName = "/pfs_v2.API/WalkBranchSubvenance"
	API_ModifyFile_FullMethodName           = "/pfs_v2.API/ModifyFile"
	API_GetFile_FullMethodName              = "/pfs_v2.API/GetFile"
	API_GetFileTAR_FullMethodName           = "/pfs_v2.API/GetFileTAR"
	API_InspectFile_FullMethodName          = "/pfs_v2.API/InspectFile"
	API_ListFile_FullMethodName             = "/pfs_v2.API/ListFile"
	API_WalkFile_FullMethodName             = "/pfs_v2.API/WalkFile"
	API_GlobFile_FullMethodName             = "/pfs_v2.API/GlobFile"
	API_DiffFile_FullMethodName             = "/pfs_v2.API/DiffFile"
	API_ActivateAuth_FullMethodName         = "/pfs_v2.API/ActivateAuth"
	API_DeleteAll_FullMethodName            = "/pfs_v2.API/DeleteAll"
	API_Fsck_FullMethodName                 = "/pfs_v2.API/Fsck"
	API_CreateFileSet_FullMethodName        = "/pfs_v2.API/CreateFileSet"
	API_GetFileSet_FullMethodName           = "/pfs_v2.API/GetFileSet"
	API_AddFileSet_FullMethodName           = "/pfs_v2.API/AddFileSet"
	API_RenewFileSet_FullMethodName         = "/pfs_v2.API/RenewFileSet"
	API_ComposeFileSet_FullMethodName       = "/pfs_v2.API/ComposeFileSet"
	API_ShardFileSet_FullMethodName         = "/pfs_v2.API/ShardFileSet"
	API_CheckStorage_FullMethodName         = "/pfs_v2.API/CheckStorage"
	API_PutCache_FullMethodName             = "/pfs_v2.API/PutCache"
	API_GetCache_FullMethodName             = "/pfs_v2.API/GetCache"
	API_ClearCache_FullMethodName           = "/pfs_v2.API/ClearCache"
	API_ListTask_FullMethodName             = "/pfs_v2.API/ListTask"
	API_Egress_FullMethodName               = "/pfs_v2.API/Egress"
	API_CreateProject_FullMethodName        = "/pfs_v2.API/CreateProject"
	API_InspectProject_FullMethodName       = "/pfs_v2.API/InspectProject"
	API_InspectProjectV2_FullMethodName     = "/pfs_v2.API/InspectProjectV2"
	API_ListProject_FullMethodName          = "/pfs_v2.API/ListProject"
	API_DeleteProject_FullMethodName        = "/pfs_v2.API/DeleteProject"
	API_ReposSummary_FullMethodName         = "/pfs_v2.API/ReposSummary"
)

// 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 {
	// CreateRepo creates a new repo.
	CreateRepo(ctx context.Context, in *CreateRepoRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// InspectRepo returns info about a repo.
	InspectRepo(ctx context.Context, in *InspectRepoRequest, opts ...grpc.CallOption) (*RepoInfo, error)
	// ListRepo returns info about all repos.
	ListRepo(ctx context.Context, in *ListRepoRequest, opts ...grpc.CallOption) (API_ListRepoClient, error)
	// DeleteRepo deletes a repo.
	DeleteRepo(ctx context.Context, in *DeleteRepoRequest, opts ...grpc.CallOption) (*DeleteRepoResponse, error)
	// DeleteRepos deletes more than one repo at once.  It attempts to
	// delete every repo matching the DeleteReposRequest.  When deleting
	// all repos matching a project, any repos not deletable by the
	// caller will remain, and the project will not be empty; this is
	// not an error.  The returned DeleteReposResponse will contain a
	// list of all actually-deleted repos.
	DeleteRepos(ctx context.Context, in *DeleteReposRequest, opts ...grpc.CallOption) (*DeleteReposResponse, error)
	// StartCommit creates a new write commit from a parent commit.
	StartCommit(ctx context.Context, in *StartCommitRequest, opts ...grpc.CallOption) (*Commit, error)
	// FinishCommit turns a write commit into a read commit.
	FinishCommit(ctx context.Context, in *FinishCommitRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// ClearCommit removes all data from the commit.
	ClearCommit(ctx context.Context, in *ClearCommitRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// InspectCommit returns the info about a commit.
	InspectCommit(ctx context.Context, in *InspectCommitRequest, opts ...grpc.CallOption) (*CommitInfo, error)
	// ListCommit returns info about all commits.
	ListCommit(ctx context.Context, in *ListCommitRequest, opts ...grpc.CallOption) (API_ListCommitClient, error)
	// SubscribeCommit subscribes for new commits on a given branch.
	SubscribeCommit(ctx context.Context, in *SubscribeCommitRequest, opts ...grpc.CallOption) (API_SubscribeCommitClient, error)
	// SquashCommit squashes the provided commit into its children.
	SquashCommit(ctx context.Context, in *SquashCommitRequest, opts ...grpc.CallOption) (*SquashCommitResponse, error)
	// DropCommit drops the provided commit.
	DropCommit(ctx context.Context, in *DropCommitRequest, opts ...grpc.CallOption) (*DropCommitResponse, error)
	// InspectCommitSet returns the info about a CommitSet.
	InspectCommitSet(ctx context.Context, in *InspectCommitSetRequest, opts ...grpc.CallOption) (API_InspectCommitSetClient, error)
	// ListCommitSet returns info about all CommitSets.
	ListCommitSet(ctx context.Context, in *ListCommitSetRequest, opts ...grpc.CallOption) (API_ListCommitSetClient, error)
	// SquashCommitSet squashes the commits of a CommitSet into their children.
	// Deprecated: Use SquashCommit instead.
	SquashCommitSet(ctx context.Context, in *SquashCommitSetRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// DropCommitSet drops the commits of a CommitSet and all data included in the commits.
	// Deprecated: Use DropCommit instead.
	DropCommitSet(ctx context.Context, in *DropCommitSetRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// FindCommits searches for commits that reference a supplied file being modified in a branch.
	FindCommits(ctx context.Context, in *FindCommitsRequest, opts ...grpc.CallOption) (API_FindCommitsClient, error)
	// WalkCommitProvenance traverses a commit's provenance graph and streams back each commit encountered.
	WalkCommitProvenance(ctx context.Context, in *WalkCommitProvenanceRequest, opts ...grpc.CallOption) (API_WalkCommitProvenanceClient, error)
	// WalkCommitSubvenance traverses a commit's subvenance graph and streams back each commit encountered.
	WalkCommitSubvenance(ctx context.Context, in *WalkCommitSubvenanceRequest, opts ...grpc.CallOption) (API_WalkCommitSubvenanceClient, error)
	// CreateBranch creates a new branch.
	CreateBranch(ctx context.Context, in *CreateBranchRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// InspectBranch returns info about a branch.
	InspectBranch(ctx context.Context, in *InspectBranchRequest, opts ...grpc.CallOption) (*BranchInfo, error)
	// ListBranch returns info about the heads of branches.
	ListBranch(ctx context.Context, in *ListBranchRequest, opts ...grpc.CallOption) (API_ListBranchClient, error)
	// DeleteBranch deletes a branch; note that the commits still exist.
	DeleteBranch(ctx context.Context, in *DeleteBranchRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// WalkBranchProvenance traverses a branch's provenance graph and streams back each branch encountered.
	WalkBranchProvenance(ctx context.Context, in *WalkBranchProvenanceRequest, opts ...grpc.CallOption) (API_WalkBranchProvenanceClient, error)
	// WalkBranchSubvenance traverses a branch's subvenance graph and streams back each branch encountered.
	WalkBranchSubvenance(ctx context.Context, in *WalkBranchSubvenanceRequest, opts ...grpc.CallOption) (API_WalkBranchSubvenanceClient, error)
	// ModifyFile performs modifications on a set of files.
	ModifyFile(ctx context.Context, opts ...grpc.CallOption) (API_ModifyFileClient, error)
	// GetFile returns the contents of a single file
	GetFile(ctx context.Context, in *GetFileRequest, opts ...grpc.CallOption) (API_GetFileClient, error)
	// GetFileTAR returns a TAR stream of the contents matched by the request
	GetFileTAR(ctx context.Context, in *GetFileRequest, opts ...grpc.CallOption) (API_GetFileTARClient, error)
	// InspectFile returns info about a file.
	InspectFile(ctx context.Context, in *InspectFileRequest, opts ...grpc.CallOption) (*FileInfo, error)
	// ListFile returns info about all files.
	ListFile(ctx context.Context, in *ListFileRequest, opts ...grpc.CallOption) (API_ListFileClient, error)
	// WalkFile walks over all the files under a directory, including children of children.
	WalkFile(ctx context.Context, in *WalkFileRequest, opts ...grpc.CallOption) (API_WalkFileClient, error)
	// GlobFile returns info about all files.
	GlobFile(ctx context.Context, in *GlobFileRequest, opts ...grpc.CallOption) (API_GlobFileClient, error)
	// DiffFile returns the differences between 2 paths at 2 commits.
	DiffFile(ctx context.Context, in *DiffFileRequest, opts ...grpc.CallOption) (API_DiffFileClient, error)
	// ActivateAuth creates a role binding for all existing repos
	ActivateAuth(ctx context.Context, in *ActivateAuthRequest, opts ...grpc.CallOption) (*ActivateAuthResponse, error)
	// DeleteAll deletes everything.
	DeleteAll(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Fsck does a file system consistency check for pfs.
	Fsck(ctx context.Context, in *FsckRequest, opts ...grpc.CallOption) (API_FsckClient, error)
	// FileSet API
	// CreateFileSet creates a new file set.
	CreateFileSet(ctx context.Context, opts ...grpc.CallOption) (API_CreateFileSetClient, error)
	// GetFileSet returns a file set with the data from a commit
	GetFileSet(ctx context.Context, in *GetFileSetRequest, opts ...grpc.CallOption) (*CreateFileSetResponse, error)
	// AddFileSet associates a file set with a commit
	AddFileSet(ctx context.Context, in *AddFileSetRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// RenewFileSet prevents a file set from being deleted for a set amount of time.
	RenewFileSet(ctx context.Context, in *RenewFileSetRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// ComposeFileSet composes a file set from a list of file sets.
	ComposeFileSet(ctx context.Context, in *ComposeFileSetRequest, opts ...grpc.CallOption) (*CreateFileSetResponse, error)
	ShardFileSet(ctx context.Context, in *ShardFileSetRequest, opts ...grpc.CallOption) (*ShardFileSetResponse, error)
	// CheckStorage runs integrity checks for the storage layer.
	CheckStorage(ctx context.Context, in *CheckStorageRequest, opts ...grpc.CallOption) (*CheckStorageResponse, error)
	PutCache(ctx context.Context, in *PutCacheRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetCache(ctx context.Context, in *GetCacheRequest, opts ...grpc.CallOption) (*GetCacheResponse, error)
	ClearCache(ctx context.Context, in *ClearCacheRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// ListTask lists PFS tasks
	ListTask(ctx context.Context, in *task.ListTaskRequest, opts ...grpc.CallOption) (API_ListTaskClient, error)
	// Egress writes data from a commit to an external system
	Egress(ctx context.Context, in *EgressRequest, opts ...grpc.CallOption) (*EgressResponse, error)
	// Project API
	// CreateProject creates a new project.
	CreateProject(ctx context.Context, in *CreateProjectRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// InspectProject returns info about a project.
	InspectProject(ctx context.Context, in *InspectProjectRequest, opts ...grpc.CallOption) (*ProjectInfo, error)
	// InspectProjectV2 returns info about and defaults for a project.
	InspectProjectV2(ctx context.Context, in *InspectProjectV2Request, opts ...grpc.CallOption) (*InspectProjectV2Response, error)
	// ListProject returns info about all projects.
	ListProject(ctx context.Context, in *ListProjectRequest, opts ...grpc.CallOption) (API_ListProjectClient, error)
	// DeleteProject deletes a project.
	DeleteProject(ctx context.Context, in *DeleteProjectRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Summary API
	// ReposSummary returns a list of summaries about the repos for each of the requested projects.
	ReposSummary(ctx context.Context, in *ReposSummaryRequest, opts ...grpc.CallOption) (*ReposSummaryResponse, error)
}

type aPIClient struct {
	cc grpc.ClientConnInterface
}

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

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

func (c *aPIClient) InspectRepo(ctx context.Context, in *InspectRepoRequest, opts ...grpc.CallOption) (*RepoInfo, error) {
	out := new(RepoInfo)
	err := c.cc.Invoke(ctx, API_InspectRepo_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) ListRepo(ctx context.Context, in *ListRepoRequest, opts ...grpc.CallOption) (API_ListRepoClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[0], API_ListRepo_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPIListRepoClient{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_ListRepoClient interface {
	Recv() (*RepoInfo, error)
	grpc.ClientStream
}

type aPIListRepoClient struct {
	grpc.ClientStream
}

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

func (c *aPIClient) DeleteRepo(ctx context.Context, in *DeleteRepoRequest, opts ...grpc.CallOption) (*DeleteRepoResponse, error) {
	out := new(DeleteRepoResponse)
	err := c.cc.Invoke(ctx, API_DeleteRepo_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) DeleteRepos(ctx context.Context, in *DeleteReposRequest, opts ...grpc.CallOption) (*DeleteReposResponse, error) {
	out := new(DeleteReposResponse)
	err := c.cc.Invoke(ctx, API_DeleteRepos_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) StartCommit(ctx context.Context, in *StartCommitRequest, opts ...grpc.CallOption) (*Commit, error) {
	out := new(Commit)
	err := c.cc.Invoke(ctx, API_StartCommit_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

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

func (c *aPIClient) InspectCommit(ctx context.Context, in *InspectCommitRequest, opts ...grpc.CallOption) (*CommitInfo, error) {
	out := new(CommitInfo)
	err := c.cc.Invoke(ctx, API_InspectCommit_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) ListCommit(ctx context.Context, in *ListCommitRequest, opts ...grpc.CallOption) (API_ListCommitClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[1], API_ListCommit_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPIListCommitClient{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_ListCommitClient interface {
	Recv() (*CommitInfo, error)
	grpc.ClientStream
}

type aPIListCommitClient struct {
	grpc.ClientStream
}

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

func (c *aPIClient) SubscribeCommit(ctx context.Context, in *SubscribeCommitRequest, opts ...grpc.CallOption) (API_SubscribeCommitClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[2], API_SubscribeCommit_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPISubscribeCommitClient{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_SubscribeCommitClient interface {
	Recv() (*CommitInfo, error)
	grpc.ClientStream
}

type aPISubscribeCommitClient struct {
	grpc.ClientStream
}

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

func (c *aPIClient) SquashCommit(ctx context.Context, in *SquashCommitRequest, opts ...grpc.CallOption) (*SquashCommitResponse, error) {
	out := new(SquashCommitResponse)
	err := c.cc.Invoke(ctx, API_SquashCommit_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) DropCommit(ctx context.Context, in *DropCommitRequest, opts ...grpc.CallOption) (*DropCommitResponse, error) {
	out := new(DropCommitResponse)
	err := c.cc.Invoke(ctx, API_DropCommit_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) InspectCommitSet(ctx context.Context, in *InspectCommitSetRequest, opts ...grpc.CallOption) (API_InspectCommitSetClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[3], API_InspectCommitSet_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPIInspectCommitSetClient{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_InspectCommitSetClient interface {
	Recv() (*CommitInfo, error)
	grpc.ClientStream
}

type aPIInspectCommitSetClient struct {
	grpc.ClientStream
}

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

func (c *aPIClient) ListCommitSet(ctx context.Context, in *ListCommitSetRequest, opts ...grpc.CallOption) (API_ListCommitSetClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[4], API_ListCommitSet_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPIListCommitSetClient{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_ListCommitSetClient interface {
	Recv() (*CommitSetInfo, error)
	grpc.ClientStream
}

type aPIListCommitSetClient struct {
	grpc.ClientStream
}

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

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

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

func (c *aPIClient) FindCommits(ctx context.Context, in *FindCommitsRequest, opts ...grpc.CallOption) (API_FindCommitsClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[5], API_FindCommits_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPIFindCommitsClient{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_FindCommitsClient interface {
	Recv() (*FindCommitsResponse, error)
	grpc.ClientStream
}

type aPIFindCommitsClient struct {
	grpc.ClientStream
}

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

func (c *aPIClient) WalkCommitProvenance(ctx context.Context, in *WalkCommitProvenanceRequest, opts ...grpc.CallOption) (API_WalkCommitProvenanceClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[6], API_WalkCommitProvenance_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPIWalkCommitProvenanceClient{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_WalkCommitProvenanceClient interface {
	Recv() (*CommitInfo, error)
	grpc.ClientStream
}

type aPIWalkCommitProvenanceClient struct {
	grpc.ClientStream
}

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

func (c *aPIClient) WalkCommitSubvenance(ctx context.Context, in *WalkCommitSubvenanceRequest, opts ...grpc.CallOption) (API_WalkCommitSubvenanceClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[7], API_WalkCommitSubvenance_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPIWalkCommitSubvenanceClient{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_WalkCommitSubvenanceClient interface {
	Recv() (*CommitInfo, error)
	grpc.ClientStream
}

type aPIWalkCommitSubvenanceClient struct {
	grpc.ClientStream
}

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

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

func (c *aPIClient) InspectBranch(ctx context.Context, in *InspectBranchRequest, opts ...grpc.CallOption) (*BranchInfo, error) {
	out := new(BranchInfo)
	err := c.cc.Invoke(ctx, API_InspectBranch_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) ListBranch(ctx context.Context, in *ListBranchRequest, opts ...grpc.CallOption) (API_ListBranchClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[8], API_ListBranch_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPIListBranchClient{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_ListBranchClient interface {
	Recv() (*BranchInfo, error)
	grpc.ClientStream
}

type aPIListBranchClient struct {
	grpc.ClientStream
}

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

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

func (c *aPIClient) WalkBranchProvenance(ctx context.Context, in *WalkBranchProvenanceRequest, opts ...grpc.CallOption) (API_WalkBranchProvenanceClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[9], API_WalkBranchProvenance_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPIWalkBranchProvenanceClient{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_WalkBranchProvenanceClient interface {
	Recv() (*BranchInfo, error)
	grpc.ClientStream
}

type aPIWalkBranchProvenanceClient struct {
	grpc.ClientStream
}

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

func (c *aPIClient) WalkBranchSubvenance(ctx context.Context, in *WalkBranchSubvenanceRequest, opts ...grpc.CallOption) (API_WalkBranchSubvenanceClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[10], API_WalkBranchSubvenance_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPIWalkBranchSubvenanceClient{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_WalkBranchSubvenanceClient interface {
	Recv() (*BranchInfo, error)
	grpc.ClientStream
}

type aPIWalkBranchSubvenanceClient struct {
	grpc.ClientStream
}

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

func (c *aPIClient) ModifyFile(ctx context.Context, opts ...grpc.CallOption) (API_ModifyFileClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[11], API_ModifyFile_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPIModifyFileClient{stream}
	return x, nil
}

type API_ModifyFileClient interface {
	Send(*ModifyFileRequest) error
	CloseAndRecv() (*emptypb.Empty, error)
	grpc.ClientStream
}

type aPIModifyFileClient struct {
	grpc.ClientStream
}

func (x *aPIModifyFileClient) Send(m *ModifyFileRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *aPIModifyFileClient) CloseAndRecv() (*emptypb.Empty, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(emptypb.Empty)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *aPIClient) GetFile(ctx context.Context, in *GetFileRequest, opts ...grpc.CallOption) (API_GetFileClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[12], API_GetFile_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPIGetFileClient{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_GetFileClient interface {
	Recv() (*wrapperspb.BytesValue, error)
	grpc.ClientStream
}

type aPIGetFileClient struct {
	grpc.ClientStream
}

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

func (c *aPIClient) GetFileTAR(ctx context.Context, in *GetFileRequest, opts ...grpc.CallOption) (API_GetFileTARClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[13], API_GetFileTAR_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPIGetFileTARClient{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_GetFileTARClient interface {
	Recv() (*wrapperspb.BytesValue, error)
	grpc.ClientStream
}

type aPIGetFileTARClient struct {
	grpc.ClientStream
}

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

func (c *aPIClient) InspectFile(ctx context.Context, in *InspectFileRequest, opts ...grpc.CallOption) (*FileInfo, error) {
	out := new(FileInfo)
	err := c.cc.Invoke(ctx, API_InspectFile_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) ListFile(ctx context.Context, in *ListFileRequest, opts ...grpc.CallOption) (API_ListFileClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[14], API_ListFile_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPIListFileClient{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_ListFileClient interface {
	Recv() (*FileInfo, error)
	grpc.ClientStream
}

type aPIListFileClient struct {
	grpc.ClientStream
}

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

func (c *aPIClient) WalkFile(ctx context.Context, in *WalkFileRequest, opts ...grpc.CallOption) (API_WalkFileClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[15], API_WalkFile_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPIWalkFileClient{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_WalkFileClient interface {
	Recv() (*FileInfo, error)
	grpc.ClientStream
}

type aPIWalkFileClient struct {
	grpc.ClientStream
}

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

func (c *aPIClient) GlobFile(ctx context.Context, in *GlobFileRequest, opts ...grpc.CallOption) (API_GlobFileClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[16], API_GlobFile_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPIGlobFileClient{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_GlobFileClient interface {
	Recv() (*FileInfo, error)
	grpc.ClientStream
}

type aPIGlobFileClient struct {
	grpc.ClientStream
}

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

func (c *aPIClient) DiffFile(ctx context.Context, in *DiffFileRequest, opts ...grpc.CallOption) (API_DiffFileClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[17], API_DiffFile_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPIDiffFileClient{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_DiffFileClient interface {
	Recv() (*DiffFileResponse, error)
	grpc.ClientStream
}

type aPIDiffFileClient struct {
	grpc.ClientStream
}

func (x *aPIDiffFileClient) Recv() (*DiffFileResponse, error) {
	m := new(DiffFileResponse)
	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) 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) Fsck(ctx context.Context, in *FsckRequest, opts ...grpc.CallOption) (API_FsckClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[18], API_Fsck_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPIFsckClient{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_FsckClient interface {
	Recv() (*FsckResponse, error)
	grpc.ClientStream
}

type aPIFsckClient struct {
	grpc.ClientStream
}

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

func (c *aPIClient) CreateFileSet(ctx context.Context, opts ...grpc.CallOption) (API_CreateFileSetClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[19], API_CreateFileSet_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPICreateFileSetClient{stream}
	return x, nil
}

type API_CreateFileSetClient interface {
	Send(*ModifyFileRequest) error
	CloseAndRecv() (*CreateFileSetResponse, error)
	grpc.ClientStream
}

type aPICreateFileSetClient struct {
	grpc.ClientStream
}

func (x *aPICreateFileSetClient) Send(m *ModifyFileRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *aPICreateFileSetClient) CloseAndRecv() (*CreateFileSetResponse, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(CreateFileSetResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *aPIClient) GetFileSet(ctx context.Context, in *GetFileSetRequest, opts ...grpc.CallOption) (*CreateFileSetResponse, error) {
	out := new(CreateFileSetResponse)
	err := c.cc.Invoke(ctx, API_GetFileSet_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

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

func (c *aPIClient) ComposeFileSet(ctx context.Context, in *ComposeFileSetRequest, opts ...grpc.CallOption) (*CreateFileSetResponse, error) {
	out := new(CreateFileSetResponse)
	err := c.cc.Invoke(ctx, API_ComposeFileSet_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) ShardFileSet(ctx context.Context, in *ShardFileSetRequest, opts ...grpc.CallOption) (*ShardFileSetResponse, error) {
	out := new(ShardFileSetResponse)
	err := c.cc.Invoke(ctx, API_ShardFileSet_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) CheckStorage(ctx context.Context, in *CheckStorageRequest, opts ...grpc.CallOption) (*CheckStorageResponse, error) {
	out := new(CheckStorageResponse)
	err := c.cc.Invoke(ctx, API_CheckStorage_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

func (c *aPIClient) GetCache(ctx context.Context, in *GetCacheRequest, opts ...grpc.CallOption) (*GetCacheResponse, error) {
	out := new(GetCacheResponse)
	err := c.cc.Invoke(ctx, API_GetCache_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) ClearCache(ctx context.Context, in *ClearCacheRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, API_ClearCache_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[20], 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) Egress(ctx context.Context, in *EgressRequest, opts ...grpc.CallOption) (*EgressResponse, error) {
	out := new(EgressResponse)
	err := c.cc.Invoke(ctx, API_Egress_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

func (c *aPIClient) InspectProject(ctx context.Context, in *InspectProjectRequest, opts ...grpc.CallOption) (*ProjectInfo, error) {
	out := new(ProjectInfo)
	err := c.cc.Invoke(ctx, API_InspectProject_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) InspectProjectV2(ctx context.Context, in *InspectProjectV2Request, opts ...grpc.CallOption) (*InspectProjectV2Response, error) {
	out := new(InspectProjectV2Response)
	err := c.cc.Invoke(ctx, API_InspectProjectV2_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aPIClient) ListProject(ctx context.Context, in *ListProjectRequest, opts ...grpc.CallOption) (API_ListProjectClient, error) {
	stream, err := c.cc.NewStream(ctx, &API_ServiceDesc.Streams[21], API_ListProject_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &aPIListProjectClient{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_ListProjectClient interface {
	Recv() (*ProjectInfo, error)
	grpc.ClientStream
}

type aPIListProjectClient struct {
	grpc.ClientStream
}

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

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

func (c *aPIClient) ReposSummary(ctx context.Context, in *ReposSummaryRequest, opts ...grpc.CallOption) (*ReposSummaryResponse, error) {
	out := new(ReposSummaryResponse)
	err := c.cc.Invoke(ctx, API_ReposSummary_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// APIServer is the server API for API service.
// All implementations must embed UnimplementedAPIServer
// for forward compatibility
type APIServer interface {
	// CreateRepo creates a new repo.
	CreateRepo(context.Context, *CreateRepoRequest) (*emptypb.Empty, error)
	// InspectRepo returns info about a repo.
	InspectRepo(context.Context, *InspectRepoRequest) (*RepoInfo, error)
	// ListRepo returns info about all repos.
	ListRepo(*ListRepoRequest, API_ListRepoServer) error
	// DeleteRepo deletes a repo.
	DeleteRepo(context.Context, *DeleteRepoRequest) (*DeleteRepoResponse, error)
	// DeleteRepos deletes more than one repo at once.  It attempts to
	// delete every repo matching the DeleteReposRequest.  When deleting
	// all repos matching a project, any repos not deletable by the
	// caller will remain, and the project will not be empty; this is
	// not an error.  The returned DeleteReposResponse will contain a
	// list of all actually-deleted repos.
	DeleteRepos(context.Context, *DeleteReposRequest) (*DeleteReposResponse, error)
	// StartCommit creates a new write commit from a parent commit.
	StartCommit(context.Context, *StartCommitRequest) (*Commit, error)
	// FinishCommit turns a write commit into a read commit.
	FinishCommit(context.Context, *FinishCommitRequest) (*emptypb.Empty, error)
	// ClearCommit removes all data from the commit.
	ClearCommit(context.Context, *ClearCommitRequest) (*emptypb.Empty, error)
	// InspectCommit returns the info about a commit.
	InspectCommit(context.Context, *InspectCommitRequest) (*CommitInfo, error)
	// ListCommit returns info about all commits.
	ListCommit(*ListCommitRequest, API_ListCommitServer) error
	// SubscribeCommit subscribes for new commits on a given branch.
	SubscribeCommit(*SubscribeCommitRequest, API_SubscribeCommitServer) error
	// SquashCommit squashes the provided commit into its children.
	SquashCommit(context.Context, *SquashCommitRequest) (*SquashCommitResponse, error)
	// DropCommit drops the provided commit.
	DropCommit(context.Context, *DropCommitRequest) (*DropCommitResponse, error)
	// InspectCommitSet returns the info about a CommitSet.
	InspectCommitSet(*InspectCommitSetRequest, API_InspectCommitSetServer) error
	// ListCommitSet returns info about all CommitSets.
	ListCommitSet(*ListCommitSetRequest, API_ListCommitSetServer) error
	// SquashCommitSet squashes the commits of a CommitSet into their children.
	// Deprecated: Use SquashCommit instead.
	SquashCommitSet(context.Context, *SquashCommitSetRequest) (*emptypb.Empty, error)
	// DropCommitSet drops the commits of a CommitSet and all data included in the commits.
	// Deprecated: Use DropCommit instead.
	DropCommitSet(context.Context, *DropCommitSetRequest) (*emptypb.Empty, error)
	// FindCommits searches for commits that reference a supplied file being modified in a branch.
	FindCommits(*FindCommitsRequest, API_FindCommitsServer) error
	// WalkCommitProvenance traverses a commit's provenance graph and streams back each commit encountered.
	WalkCommitProvenance(*WalkCommitProvenanceRequest, API_WalkCommitProvenanceServer) error
	// WalkCommitSubvenance traverses a commit's subvenance graph and streams back each commit encountered.
	WalkCommitSubvenance(*WalkCommitSubvenanceRequest, API_WalkCommitSubvenanceServer) error
	// CreateBranch creates a new branch.
	CreateBranch(context.Context, *CreateBranchRequest) (*emptypb.Empty, error)
	// InspectBranch returns info about a branch.
	InspectBranch(context.Context, *InspectBranchRequest) (*BranchInfo, error)
	// ListBranch returns info about the heads of branches.
	ListBranch(*ListBranchRequest, API_ListBranchServer) error
	// DeleteBranch deletes a branch; note that the commits still exist.
	DeleteBranch(context.Context, *DeleteBranchRequest) (*emptypb.Empty, error)
	// WalkBranchProvenance traverses a branch's provenance graph and streams back each branch encountered.
	WalkBranchProvenance(*WalkBranchProvenanceRequest, API_WalkBranchProvenanceServer) error
	// WalkBranchSubvenance traverses a branch's subvenance graph and streams back each branch encountered.
	WalkBranchSubvenance(*WalkBranchSubvenanceRequest, API_WalkBranchSubvenanceServer) error
	// ModifyFile performs modifications on a set of files.
	ModifyFile(API_ModifyFileServer) error
	// GetFile returns the contents of a single file
	GetFile(*GetFileRequest, API_GetFileServer) error
	// GetFileTAR returns a TAR stream of the contents matched by the request
	GetFileTAR(*GetFileRequest, API_GetFileTARServer) error
	// InspectFile returns info about a file.
	InspectFile(context.Context, *InspectFileRequest) (*FileInfo, error)
	// ListFile returns info about all files.
	ListFile(*ListFileRequest, API_ListFileServer) error
	// WalkFile walks over all the files under a directory, including children of children.
	WalkFile(*WalkFileRequest, API_WalkFileServer) error
	// GlobFile returns info about all files.
	GlobFile(*GlobFileRequest, API_GlobFileServer) error
	// DiffFile returns the differences between 2 paths at 2 commits.
	DiffFile(*DiffFileRequest, API_DiffFileServer) error
	// ActivateAuth creates a role binding for all existing repos
	ActivateAuth(context.Context, *ActivateAuthRequest) (*ActivateAuthResponse, error)
	// DeleteAll deletes everything.
	DeleteAll(context.Context, *emptypb.Empty) (*emptypb.Empty, error)
	// Fsck does a file system consistency check for pfs.
	Fsck(*FsckRequest, API_FsckServer) error
	// FileSet API
	// CreateFileSet creates a new file set.
	CreateFileSet(API_CreateFileSetServer) error
	// GetFileSet returns a file set with the data from a commit
	GetFileSet(context.Context, *GetFileSetRequest) (*CreateFileSetResponse, error)
	// AddFileSet associates a file set with a commit
	AddFileSet(context.Context, *AddFileSetRequest) (*emptypb.Empty, error)
	// RenewFileSet prevents a file set from being deleted for a set amount of time.
	RenewFileSet(context.Context, *RenewFileSetRequest) (*emptypb.Empty, error)
	// ComposeFileSet composes a file set from a list of file sets.
	ComposeFileSet(context.Context, *ComposeFileSetRequest) (*CreateFileSetResponse, error)
	ShardFileSet(context.Context, *ShardFileSetRequest) (*ShardFileSetResponse, error)
	// CheckStorage runs integrity checks for the storage layer.
	CheckStorage(context.Context, *CheckStorageRequest) (*CheckStorageResponse, error)
	PutCache(context.Context, *PutCacheRequest) (*emptypb.Empty, error)
	GetCache(context.Context, *GetCacheRequest) (*GetCacheResponse, error)
	ClearCache(context.Context, *ClearCacheRequest) (*emptypb.Empty, error)
	// ListTask lists PFS tasks
	ListTask(*task.ListTaskRequest, API_ListTaskServer) error
	// Egress writes data from a commit to an external system
	Egress(context.Context, *EgressRequest) (*EgressResponse, error)
	// Project API
	// CreateProject creates a new project.
	CreateProject(context.Context, *CreateProjectRequest) (*emptypb.Empty, error)
	// InspectProject returns info about a project.
	InspectProject(context.Context, *InspectProjectRequest) (*ProjectInfo, error)
	// InspectProjectV2 returns info about and defaults for a project.
	InspectProjectV2(context.Context, *InspectProjectV2Request) (*InspectProjectV2Response, error)
	// ListProject returns info about all projects.
	ListProject(*ListProjectRequest, API_ListProjectServer) error
	// DeleteProject deletes a project.
	DeleteProject(context.Context, *DeleteProjectRequest) (*emptypb.Empty, error)
	// Summary API
	// ReposSummary returns a list of summaries about the repos for each of the requested projects.
	ReposSummary(context.Context, *ReposSummaryRequest) (*ReposSummaryResponse, error)
	mustEmbedUnimplementedAPIServer()
}

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

func (UnimplementedAPIServer) CreateRepo(context.Context, *CreateRepoRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateRepo not implemented")
}
func (UnimplementedAPIServer) InspectRepo(context.Context, *InspectRepoRequest) (*RepoInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InspectRepo not implemented")
}
func (UnimplementedAPIServer) ListRepo(*ListRepoRequest, API_ListRepoServer) error {
	return status.Errorf(codes.Unimplemented, "method ListRepo not implemented")
}
func (UnimplementedAPIServer) DeleteRepo(context.Context, *DeleteRepoRequest) (*DeleteRepoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteRepo not implemented")
}
func (UnimplementedAPIServer) DeleteRepos(context.Context, *DeleteReposRequest) (*DeleteReposResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteRepos not implemented")
}
func (UnimplementedAPIServer) StartCommit(context.Context, *StartCommitRequest) (*Commit, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartCommit not implemented")
}
func (UnimplementedAPIServer) FinishCommit(context.Context, *FinishCommitRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FinishCommit not implemented")
}
func (UnimplementedAPIServer) ClearCommit(context.Context, *ClearCommitRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ClearCommit not implemented")
}
func (UnimplementedAPIServer) InspectCommit(context.Context, *InspectCommitRequest) (*CommitInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InspectCommit not implemented")
}
func (UnimplementedAPIServer) ListCommit(*ListCommitRequest, API_ListCommitServer) error {
	return status.Errorf(codes.Unimplemented, "method ListCommit not implemented")
}
func (UnimplementedAPIServer) SubscribeCommit(*SubscribeCommitRequest, API_SubscribeCommitServer) error {
	return status.Errorf(codes.Unimplemented, "method SubscribeCommit not implemented")
}
func (UnimplementedAPIServer) SquashCommit(context.Context, *SquashCommitRequest) (*SquashCommitResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SquashCommit not implemented")
}
func (UnimplementedAPIServer) DropCommit(context.Context, *DropCommitRequest) (*DropCommitResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DropCommit not implemented")
}
func (UnimplementedAPIServer) InspectCommitSet(*InspectCommitSetRequest, API_InspectCommitSetServer) error {
	return status.Errorf(codes.Unimplemented, "method InspectCommitSet not implemented")
}
func (UnimplementedAPIServer) ListCommitSet(*ListCommitSetRequest, API_ListCommitSetServer) error {
	return status.Errorf(codes.Unimplemented, "method ListCommitSet not implemented")
}
func (UnimplementedAPIServer) SquashCommitSet(context.Context, *SquashCommitSetRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SquashCommitSet not implemented")
}
func (UnimplementedAPIServer) DropCommitSet(context.Context, *DropCommitSetRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DropCommitSet not implemented")
}
func (UnimplementedAPIServer) FindCommits(*FindCommitsRequest, API_FindCommitsServer) error {
	return status.Errorf(codes.Unimplemented, "method FindCommits not implemented")
}
func (UnimplementedAPIServer) WalkCommitProvenance(*WalkCommitProvenanceRequest, API_WalkCommitProvenanceServer) error {
	return status.Errorf(codes.Unimplemented, "method WalkCommitProvenance not implemented")
}
func (UnimplementedAPIServer) WalkCommitSubvenance(*WalkCommitSubvenanceRequest, API_WalkCommitSubvenanceServer) error {
	return status.Errorf(codes.Unimplemented, "method WalkCommitSubvenance not implemented")
}
func (UnimplementedAPIServer) CreateBranch(context.Context, *CreateBranchRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateBranch not implemented")
}
func (UnimplementedAPIServer) InspectBranch(context.Context, *InspectBranchRequest) (*BranchInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InspectBranch not implemented")
}
func (UnimplementedAPIServer) ListBranch(*ListBranchRequest, API_ListBranchServer) error {
	return status.Errorf(codes.Unimplemented, "method ListBranch not implemented")
}
func (UnimplementedAPIServer) DeleteBranch(context.Context, *DeleteBranchRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteBranch not implemented")
}
func (UnimplementedAPIServer) WalkBranchProvenance(*WalkBranchProvenanceRequest, API_WalkBranchProvenanceServer) error {
	return status.Errorf(codes.Unimplemented, "method WalkBranchProvenance not implemented")
}
func (UnimplementedAPIServer) WalkBranchSubvenance(*WalkBranchSubvenanceRequest, API_WalkBranchSubvenanceServer) error {
	return status.Errorf(codes.Unimplemented, "method WalkBranchSubvenance not implemented")
}
func (UnimplementedAPIServer) ModifyFile(API_ModifyFileServer) error {
	return status.Errorf(codes.Unimplemented, "method ModifyFile not implemented")
}
func (UnimplementedAPIServer) GetFile(*GetFileRequest, API_GetFileServer) error {
	return status.Errorf(codes.Unimplemented, "method GetFile not implemented")
}
func (UnimplementedAPIServer) GetFileTAR(*GetFileRequest, API_GetFileTARServer) error {
	return status.Errorf(codes.Unimplemented, "method GetFileTAR not implemented")
}
func (UnimplementedAPIServer) InspectFile(context.Context, *InspectFileRequest) (*FileInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InspectFile not implemented")
}
func (UnimplementedAPIServer) ListFile(*ListFileRequest, API_ListFileServer) error {
	return status.Errorf(codes.Unimplemented, "method ListFile not implemented")
}
func (UnimplementedAPIServer) WalkFile(*WalkFileRequest, API_WalkFileServer) error {
	return status.Errorf(codes.Unimplemented, "method WalkFile not implemented")
}
func (UnimplementedAPIServer) GlobFile(*GlobFileRequest, API_GlobFileServer) error {
	return status.Errorf(codes.Unimplemented, "method GlobFile not implemented")
}
func (UnimplementedAPIServer) DiffFile(*DiffFileRequest, API_DiffFileServer) error {
	return status.Errorf(codes.Unimplemented, "method DiffFile not implemented")
}
func (UnimplementedAPIServer) ActivateAuth(context.Context, *ActivateAuthRequest) (*ActivateAuthResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ActivateAuth not implemented")
}
func (UnimplementedAPIServer) DeleteAll(context.Context, *emptypb.Empty) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteAll not implemented")
}
func (UnimplementedAPIServer) Fsck(*FsckRequest, API_FsckServer) error {
	return status.Errorf(codes.Unimplemented, "method Fsck not implemented")
}
func (UnimplementedAPIServer) CreateFileSet(API_CreateFileSetServer) error {
	return status.Errorf(codes.Unimplemented, "method CreateFileSet not implemented")
}
func (UnimplementedAPIServer) GetFileSet(context.Context, *GetFileSetRequest) (*CreateFileSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetFileSet not implemented")
}
func (UnimplementedAPIServer) AddFileSet(context.Context, *AddFileSetRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddFileSet not implemented")
}
func (UnimplementedAPIServer) RenewFileSet(context.Context, *RenewFileSetRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RenewFileSet not implemented")
}
func (UnimplementedAPIServer) ComposeFileSet(context.Context, *ComposeFileSetRequest) (*CreateFileSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ComposeFileSet not implemented")
}
func (UnimplementedAPIServer) ShardFileSet(context.Context, *ShardFileSetRequest) (*ShardFileSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ShardFileSet not implemented")
}
func (UnimplementedAPIServer) CheckStorage(context.Context, *CheckStorageRequest) (*CheckStorageResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CheckStorage not implemented")
}
func (UnimplementedAPIServer) PutCache(context.Context, *PutCacheRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PutCache not implemented")
}
func (UnimplementedAPIServer) GetCache(context.Context, *GetCacheRequest) (*GetCacheResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCache not implemented")
}
func (UnimplementedAPIServer) ClearCache(context.Context, *ClearCacheRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ClearCache not implemented")
}
func (UnimplementedAPIServer) ListTask(*task.ListTaskRequest, API_ListTaskServer) error {
	return status.Errorf(codes.Unimplemented, "method ListTask not implemented")
}
func (UnimplementedAPIServer) Egress(context.Context, *EgressRequest) (*EgressResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Egress not implemented")
}
func (UnimplementedAPIServer) CreateProject(context.Context, *CreateProjectRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateProject not implemented")
}
func (UnimplementedAPIServer) InspectProject(context.Context, *InspectProjectRequest) (*ProjectInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InspectProject not implemented")
}
func (UnimplementedAPIServer) InspectProjectV2(context.Context, *InspectProjectV2Request) (*InspectProjectV2Response, error) {
	return nil, status.Errorf(codes.Unimplemented, "method InspectProjectV2 not implemented")
}
func (UnimplementedAPIServer) ListProject(*ListProjectRequest, API_ListProjectServer) error {
	return status.Errorf(codes.Unimplemented, "method ListProject not implemented")
}
func (UnimplementedAPIServer) DeleteProject(context.Context, *DeleteProjectRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteProject not implemented")
}
func (UnimplementedAPIServer) ReposSummary(context.Context, *ReposSummaryRequest) (*ReposSummaryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReposSummary 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_CreateRepo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateRepoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(APIServer).CreateRepo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: API_CreateRepo_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(APIServer).CreateRepo(ctx, req.(*CreateRepoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

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

func _API_ListRepo_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListRepoRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).ListRepo(m, &aPIListRepoServer{stream})
}

type API_ListRepoServer interface {
	Send(*RepoInfo) error
	grpc.ServerStream
}

type aPIListRepoServer struct {
	grpc.ServerStream
}

func (x *aPIListRepoServer) Send(m *RepoInfo) error {
	return x.ServerStream.SendMsg(m)
}

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

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

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

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

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

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

func _API_ListCommit_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListCommitRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).ListCommit(m, &aPIListCommitServer{stream})
}

type API_ListCommitServer interface {
	Send(*CommitInfo) error
	grpc.ServerStream
}

type aPIListCommitServer struct {
	grpc.ServerStream
}

func (x *aPIListCommitServer) Send(m *CommitInfo) error {
	return x.ServerStream.SendMsg(m)
}

func _API_SubscribeCommit_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(SubscribeCommitRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).SubscribeCommit(m, &aPISubscribeCommitServer{stream})
}

type API_SubscribeCommitServer interface {
	Send(*CommitInfo) error
	grpc.ServerStream
}

type aPISubscribeCommitServer struct {
	grpc.ServerStream
}

func (x *aPISubscribeCommitServer) Send(m *CommitInfo) error {
	return x.ServerStream.SendMsg(m)
}

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

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

func _API_InspectCommitSet_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(InspectCommitSetRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).InspectCommitSet(m, &aPIInspectCommitSetServer{stream})
}

type API_InspectCommitSetServer interface {
	Send(*CommitInfo) error
	grpc.ServerStream
}

type aPIInspectCommitSetServer struct {
	grpc.ServerStream
}

func (x *aPIInspectCommitSetServer) Send(m *CommitInfo) error {
	return x.ServerStream.SendMsg(m)
}

func _API_ListCommitSet_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListCommitSetRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).ListCommitSet(m, &aPIListCommitSetServer{stream})
}

type API_ListCommitSetServer interface {
	Send(*CommitSetInfo) error
	grpc.ServerStream
}

type aPIListCommitSetServer struct {
	grpc.ServerStream
}

func (x *aPIListCommitSetServer) Send(m *CommitSetInfo) error {
	return x.ServerStream.SendMsg(m)
}

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

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

func _API_FindCommits_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(FindCommitsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).FindCommits(m, &aPIFindCommitsServer{stream})
}

type API_FindCommitsServer interface {
	Send(*FindCommitsResponse) error
	grpc.ServerStream
}

type aPIFindCommitsServer struct {
	grpc.ServerStream
}

func (x *aPIFindCommitsServer) Send(m *FindCommitsResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _API_WalkCommitProvenance_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WalkCommitProvenanceRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).WalkCommitProvenance(m, &aPIWalkCommitProvenanceServer{stream})
}

type API_WalkCommitProvenanceServer interface {
	Send(*CommitInfo) error
	grpc.ServerStream
}

type aPIWalkCommitProvenanceServer struct {
	grpc.ServerStream
}

func (x *aPIWalkCommitProvenanceServer) Send(m *CommitInfo) error {
	return x.ServerStream.SendMsg(m)
}

func _API_WalkCommitSubvenance_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WalkCommitSubvenanceRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).WalkCommitSubvenance(m, &aPIWalkCommitSubvenanceServer{stream})
}

type API_WalkCommitSubvenanceServer interface {
	Send(*CommitInfo) error
	grpc.ServerStream
}

type aPIWalkCommitSubvenanceServer struct {
	grpc.ServerStream
}

func (x *aPIWalkCommitSubvenanceServer) Send(m *CommitInfo) error {
	return x.ServerStream.SendMsg(m)
}

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

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

func _API_ListBranch_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListBranchRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).ListBranch(m, &aPIListBranchServer{stream})
}

type API_ListBranchServer interface {
	Send(*BranchInfo) error
	grpc.ServerStream
}

type aPIListBranchServer struct {
	grpc.ServerStream
}

func (x *aPIListBranchServer) Send(m *BranchInfo) error {
	return x.ServerStream.SendMsg(m)
}

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

func _API_WalkBranchProvenance_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WalkBranchProvenanceRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).WalkBranchProvenance(m, &aPIWalkBranchProvenanceServer{stream})
}

type API_WalkBranchProvenanceServer interface {
	Send(*BranchInfo) error
	grpc.ServerStream
}

type aPIWalkBranchProvenanceServer struct {
	grpc.ServerStream
}

func (x *aPIWalkBranchProvenanceServer) Send(m *BranchInfo) error {
	return x.ServerStream.SendMsg(m)
}

func _API_WalkBranchSubvenance_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WalkBranchSubvenanceRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).WalkBranchSubvenance(m, &aPIWalkBranchSubvenanceServer{stream})
}

type API_WalkBranchSubvenanceServer interface {
	Send(*BranchInfo) error
	grpc.ServerStream
}

type aPIWalkBranchSubvenanceServer struct {
	grpc.ServerStream
}

func (x *aPIWalkBranchSubvenanceServer) Send(m *BranchInfo) error {
	return x.ServerStream.SendMsg(m)
}

func _API_ModifyFile_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(APIServer).ModifyFile(&aPIModifyFileServer{stream})
}

type API_ModifyFileServer interface {
	SendAndClose(*emptypb.Empty) error
	Recv() (*ModifyFileRequest, error)
	grpc.ServerStream
}

type aPIModifyFileServer struct {
	grpc.ServerStream
}

func (x *aPIModifyFileServer) SendAndClose(m *emptypb.Empty) error {
	return x.ServerStream.SendMsg(m)
}

func (x *aPIModifyFileServer) Recv() (*ModifyFileRequest, error) {
	m := new(ModifyFileRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _API_GetFile_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetFileRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).GetFile(m, &aPIGetFileServer{stream})
}

type API_GetFileServer interface {
	Send(*wrapperspb.BytesValue) error
	grpc.ServerStream
}

type aPIGetFileServer struct {
	grpc.ServerStream
}

func (x *aPIGetFileServer) Send(m *wrapperspb.BytesValue) error {
	return x.ServerStream.SendMsg(m)
}

func _API_GetFileTAR_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetFileRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).GetFileTAR(m, &aPIGetFileTARServer{stream})
}

type API_GetFileTARServer interface {
	Send(*wrapperspb.BytesValue) error
	grpc.ServerStream
}

type aPIGetFileTARServer struct {
	grpc.ServerStream
}

func (x *aPIGetFileTARServer) Send(m *wrapperspb.BytesValue) error {
	return x.ServerStream.SendMsg(m)
}

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

func _API_ListFile_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListFileRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).ListFile(m, &aPIListFileServer{stream})
}

type API_ListFileServer interface {
	Send(*FileInfo) error
	grpc.ServerStream
}

type aPIListFileServer struct {
	grpc.ServerStream
}

func (x *aPIListFileServer) Send(m *FileInfo) error {
	return x.ServerStream.SendMsg(m)
}

func _API_WalkFile_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WalkFileRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).WalkFile(m, &aPIWalkFileServer{stream})
}

type API_WalkFileServer interface {
	Send(*FileInfo) error
	grpc.ServerStream
}

type aPIWalkFileServer struct {
	grpc.ServerStream
}

func (x *aPIWalkFileServer) Send(m *FileInfo) error {
	return x.ServerStream.SendMsg(m)
}

func _API_GlobFile_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GlobFileRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).GlobFile(m, &aPIGlobFileServer{stream})
}

type API_GlobFileServer interface {
	Send(*FileInfo) error
	grpc.ServerStream
}

type aPIGlobFileServer struct {
	grpc.ServerStream
}

func (x *aPIGlobFileServer) Send(m *FileInfo) error {
	return x.ServerStream.SendMsg(m)
}

func _API_DiffFile_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(DiffFileRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).DiffFile(m, &aPIDiffFileServer{stream})
}

type API_DiffFileServer interface {
	Send(*DiffFileResponse) error
	grpc.ServerStream
}

type aPIDiffFileServer struct {
	grpc.ServerStream
}

func (x *aPIDiffFileServer) Send(m *DiffFileResponse) 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_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_Fsck_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(FsckRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).Fsck(m, &aPIFsckServer{stream})
}

type API_FsckServer interface {
	Send(*FsckResponse) error
	grpc.ServerStream
}

type aPIFsckServer struct {
	grpc.ServerStream
}

func (x *aPIFsckServer) Send(m *FsckResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _API_CreateFileSet_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(APIServer).CreateFileSet(&aPICreateFileSetServer{stream})
}

type API_CreateFileSetServer interface {
	SendAndClose(*CreateFileSetResponse) error
	Recv() (*ModifyFileRequest, error)
	grpc.ServerStream
}

type aPICreateFileSetServer struct {
	grpc.ServerStream
}

func (x *aPICreateFileSetServer) SendAndClose(m *CreateFileSetResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *aPICreateFileSetServer) Recv() (*ModifyFileRequest, error) {
	m := new(ModifyFileRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

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

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

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

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

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

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

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

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

func _API_ClearCache_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ClearCacheRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(APIServer).ClearCache(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: API_ClearCache_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(APIServer).ClearCache(ctx, req.(*ClearCacheRequest))
	}
	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_Egress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EgressRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(APIServer).Egress(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: API_Egress_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(APIServer).Egress(ctx, req.(*EgressRequest))
	}
	return interceptor(ctx, in, info, handler)
}

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

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

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

func _API_ListProject_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ListProjectRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(APIServer).ListProject(m, &aPIListProjectServer{stream})
}

type API_ListProjectServer interface {
	Send(*ProjectInfo) error
	grpc.ServerStream
}

type aPIListProjectServer struct {
	grpc.ServerStream
}

func (x *aPIListProjectServer) Send(m *ProjectInfo) error {
	return x.ServerStream.SendMsg(m)
}

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

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

// 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: "pfs_v2.API",
	HandlerType: (*APIServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateRepo",
			Handler:    _API_CreateRepo_Handler,
		},
		{
			MethodName: "InspectRepo",
			Handler:    _API_InspectRepo_Handler,
		},
		{
			MethodName: "DeleteRepo",
			Handler:    _API_DeleteRepo_Handler,
		},
		{
			MethodName: "DeleteRepos",
			Handler:    _API_DeleteRepos_Handler,
		},
		{
			MethodName: "StartCommit",
			Handler:    _API_StartCommit_Handler,
		},
		{
			MethodName: "FinishCommit",
			Handler:    _API_FinishCommit_Handler,
		},
		{
			MethodName: "ClearCommit",
			Handler:    _API_ClearCommit_Handler,
		},
		{
			MethodName: "InspectCommit",
			Handler:    _API_InspectCommit_Handler,
		},
		{
			MethodName: "SquashCommit",
			Handler:    _API_SquashCommit_Handler,
		},
		{
			MethodName: "DropCommit",
			Handler:    _API_DropCommit_Handler,
		},
		{
			MethodName: "SquashCommitSet",
			Handler:    _API_SquashCommitSet_Handler,
		},
		{
			MethodName: "DropCommitSet",
			Handler:    _API_DropCommitSet_Handler,
		},
		{
			MethodName: "CreateBranch",
			Handler:    _API_CreateBranch_Handler,
		},
		{
			MethodName: "InspectBranch",
			Handler:    _API_InspectBranch_Handler,
		},
		{
			MethodName: "DeleteBranch",
			Handler:    _API_DeleteBranch_Handler,
		},
		{
			MethodName: "InspectFile",
			Handler:    _API_InspectFile_Handler,
		},
		{
			MethodName: "ActivateAuth",
			Handler:    _API_ActivateAuth_Handler,
		},
		{
			MethodName: "DeleteAll",
			Handler:    _API_DeleteAll_Handler,
		},
		{
			MethodName: "GetFileSet",
			Handler:    _API_GetFileSet_Handler,
		},
		{
			MethodName: "AddFileSet",
			Handler:    _API_AddFileSet_Handler,
		},
		{
			MethodName: "RenewFileSet",
			Handler:    _API_RenewFileSet_Handler,
		},
		{
			MethodName: "ComposeFileSet",
			Handler:    _API_ComposeFileSet_Handler,
		},
		{
			MethodName: "ShardFileSet",
			Handler:    _API_ShardFileSet_Handler,
		},
		{
			MethodName: "CheckStorage",
			Handler:    _API_CheckStorage_Handler,
		},
		{
			MethodName: "PutCache",
			Handler:    _API_PutCache_Handler,
		},
		{
			MethodName: "GetCache",
			Handler:    _API_GetCache_Handler,
		},
		{
			MethodName: "ClearCache",
			Handler:    _API_ClearCache_Handler,
		},
		{
			MethodName: "Egress",
			Handler:    _API_Egress_Handler,
		},
		{
			MethodName: "CreateProject",
			Handler:    _API_CreateProject_Handler,
		},
		{
			MethodName: "InspectProject",
			Handler:    _API_InspectProject_Handler,
		},
		{
			MethodName: "InspectProjectV2",
			Handler:    _API_InspectProjectV2_Handler,
		},
		{
			MethodName: "DeleteProject",
			Handler:    _API_DeleteProject_Handler,
		},
		{
			MethodName: "ReposSummary",
			Handler:    _API_ReposSummary_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ListRepo",
			Handler:       _API_ListRepo_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListCommit",
			Handler:       _API_ListCommit_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "SubscribeCommit",
			Handler:       _API_SubscribeCommit_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "InspectCommitSet",
			Handler:       _API_InspectCommitSet_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListCommitSet",
			Handler:       _API_ListCommitSet_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "FindCommits",
			Handler:       _API_FindCommits_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "WalkCommitProvenance",
			Handler:       _API_WalkCommitProvenance_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "WalkCommitSubvenance",
			Handler:       _API_WalkCommitSubvenance_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListBranch",
			Handler:       _API_ListBranch_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "WalkBranchProvenance",
			Handler:       _API_WalkBranchProvenance_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "WalkBranchSubvenance",
			Handler:       _API_WalkBranchSubvenance_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ModifyFile",
			Handler:       _API_ModifyFile_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "GetFile",
			Handler:       _API_GetFile_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetFileTAR",
			Handler:       _API_GetFileTAR_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListFile",
			Handler:       _API_ListFile_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "WalkFile",
			Handler:       _API_WalkFile_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GlobFile",
			Handler:       _API_GlobFile_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "DiffFile",
			Handler:       _API_DiffFile_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Fsck",
			Handler:       _API_Fsck_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "CreateFileSet",
			Handler:       _API_CreateFileSet_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "ListTask",
			Handler:       _API_ListTask_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ListProject",
			Handler:       _API_ListProject_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "pfs/pfs.proto",
}